标签：#coding

With this update, users can start a task from their desk, get status updates on their phone, and pick up the finished output later — even if their laptop is closed.

Cursor is the first AI code editor I have used that feels less like an autocomplete plugin and more like a place to steer work. It does not write perfect software. It changes the rhythm: ask for a scoped change, review the diff, then tighten it by hand. This Cursor AI review is based on day-to-day developer tasks: reading unfamiliar code, editing React components, moving logic between files, writing tests, and asking the editor to explain errors from the terminal. The short version is simple: Cursor is excellent when a task crosses file boundaries. It is less convincing when you only need cheap inline completions. What Cursor Actually Is Cursor is a VS Code-based editor from Anysphere with AI built into the core experience. Extensions, settings, themes, terminal panes, source control, and the familiar layout are still there. The difference is that chat, agent-style edits, tab completion, codebase search, and model selection are treated as editor controls rather than add-ons. That matters in daily use. I found the chat panel most useful when I pointed it at a directory and asked for a narrow change, such as "move this validation into the shared helper and update the tests." Cursor could usually find the right files, make a first pass, and leave me with a readable diff. I still had to check naming, edge cases, and test coverage, but it saved the boring part of hunting through files. The Best Part: Multi-File Editing Cursor's strongest feature is multi-file editing with codebase context. A lot of AI coding assistants can finish a function. Fewer can update the component, the hook, the type definition, and the test in one pass without losing the shape of the project. In my experience, Cursor is at its best with medium-sized tasks. It handles "add a field to this form and wire it through the API call" better than "invent a new architecture." It also works well for cleanup: renaming a concept, extracting repeated logic, or adding a missing test around an existing pattern.

Building Lethe, a polygraph for AI memory, on Cognee. Every demo I have seen this year is about making AI remember more. Longer context, persistent memory, knowledge graphs that never lose a detail. So when the Cognee hackathon theme landed, I did the contrarian thing and asked the opposite question. When an AI deletes your data, can it prove it forgot? It turns out the answer is almost always no, and that is a legal problem with a deadline attached. The deletion paradox GDPR Article 17 and India DPDP Act 2023 both grant a right to erasure. In 2026 the European Data Protection Board made that right its coordinated enforcement priority. Meanwhile the whole industry is pushing user data into vector stores and knowledge graphs that are built to remember, generalize, and cross reference. Here is the uncomfortable part. Suppose you call forget for a user. What actually happened? The user's document is deleted. Good. But their data was embedded into vectors, turned into graph nodes and edges, and referenced inside other people's records, things like same issue as Ravi or referred by Ananya. Those are derived memory artifacts. Deleting the source row does not necessarily remove them. So we deleted it is a claim, not a proof. I wanted to build the proof. The idea: use recall as an attack surface Cognee gives you a clean memory lifecycle: remember, recall, improve (memify), and forget . Everyone uses recall to get answers. I used it as a weapon. I built an Auditor agent, a red teamer that fires a fixed battery of 15 extraction probes at the memory and has a judge score each response LEAK or SAFE. Four attack classes: Direct. What is Ravi Sharma's phone number? Inference. Which customer complained about a failed UPI refund in March? This re-identifies without naming. Reconstruction. List every complaint above ten thousand rupees, with names. Relational. Which customers had the same issue as Ravi? This checks whether a deleted node still leaks through graph edges. The probes a

Alright, real talk moment. Last week I watched someone with zero coding background build a fully...

The Problem Nobody Talks About Everyone's posting AI-generated videos — characters speaking with lip-sync, manga panels coming alive, virtual idols dancing. The pitch: "just describe what you want." I tried. For months. Here's what I got: Character's face morphed by frame 2 "Slowly looks up" became "violent head shake" Voice-over sounded like Google Translate Same prompt, 3 runs, 3 completely different results No idea what to include or how long the prompt should be Tutorials were either too vague ("be detailed") or too technical (parameter tuning from line 1). The real issue: video prompts are structurally different from text/image prompts. You need to simultaneously control visuals, motion, audio, camera, and consistency constraints — in the right order, at the right length. What I Found A Skill in the Model Studio official repo called happyhorse-prompt-studio . It doesn't teach you theory — it asks you questions and assembles the prompt for you . 4-phase flow: 1. Inspiration Menu Shows you 4 "flavors" of what HappyHorse can do: Flavor What it does A · Voiced Manga Drama Characters talk to each other, with voice + lip-sync B · Character Voice PV Single character self-introduction, 8-10 sec C · Manga Panel Motion Static manga panel starts breathing D · Virtual Idol MV Idol performance with choreography 2. Discovery Asks you conversationally: character appearance, scene, emotion, dialogue, voice type, art style, camera. 3. Prompt Assembly Assembles using the HappyHorse Formula : Scene + Subject + Motion + Audio + Quality Key techniques: @「Image n」 syntax locks character identity across shots Dialogue ≤15 characters (split shots if longer) Japanese prompts work best (HappyHorse is JP-optimized) Always end with キャラの顔・髪・衣装が変わらない (face/hair/outfit stays unchanged) 4. Quality Check Auto-reviews: completeness, compliance, cost estimate, optimization tips. Before vs. After Dimension Writing myself With Prompt Studio Attempts needed 10-20 before one usable 2-3 to satisfacti

1:00 AM to 2:27 AM. One bug, three root causes, zero clean error messages. It started with a simple complaint: an admin sends a push notification, and the user never receives it. No crash, no red error in the console, nothing obviously broken. Just silence on the other end. That kind of bug is the most frustrating kind. Everything looks like it's working. The permission prompt shows up fine. The admin panel says "sent." And yet nothing arrives. By 1 AM, after a long day already spent on a fairly large project, this was the last thing left to fix before calling it a night. It turned into an hour and a half of tracing one silent failure into another. Layer One: The CSP Was Blocking the Fix Before It Could Even Start The first clue showed up in the browser console: a Content Security Policy violation, quietly blocking a script that OneSignal's SDK needed to complete its own initialization. The permission popup looked completely normal, so it was easy to assume the subscription step was working. It wasn't. The script that OneSignal used internally to finish setting up the subscription was being blocked by the site's own security headers. The fix was small: add the missing domain to the script-src directive. But finding it meant not trusting what the UI looked like it was doing, and instead reading the actual network requests line by line. Layer Two: "Sent" and "Delivered" Are Not the Same Thing Once the CSP was fixed, notifications appeared to send successfully. The API returned a success response, an ID was created, and the admin panel showed a "sent" confirmation. Except the user still got nothing. This turned out to be a subtler problem. OneSignal's newer API doesn't return a recipient count in that initial response, so a message could be "created" successfully by OneSignal's servers while still reaching zero actual devices. The code was treating message creation as proof of delivery, which is not the same thing at all. The fix involved polling OneSignal's delivery-s

AI coding assistants are great at writing code and terrible at knowing when to write it. Ask one to build a feature and it will happily jump straight to implementation, skipping the questions a good engineer asks first: what exactly are we building, why, what are the risks, and how should it be broken down? The result is fast output that often solves the wrong problem. AWS's AI-DLC (AI-Driven Development Life Cycle) is an attempt to fix that gap. It's an open-source set of workflow rules — released by awslabs — that steer AI coding agents through a disciplined software development process instead of letting them freewheel. Importantly, it isn't a tool you install or a service you pay for. It's a methodology delivered as a bundle of markdown rules that your existing coding agent reads and follows. The core idea: methodology over tooling One of AI-DLC's stated tenets is "methodology first." The whole thing ships as plain markdown rule files that you drop into whatever your agent already uses for project instructions — CLAUDE.md for Claude Code, .cursor/rules/ for Cursor, .github/copilot-instructions.md for GitHub Copilot, .amazonq/rules/ for Amazon Q, steering files for Kiro, and so on. There's nothing to run. The agent loads the rules and its behavior changes. This makes AI-DLC deliberately agnostic . It doesn't tie you to a specific IDE, model, or vendor — any coding agent that supports project-level rules can use it. The philosophy is that a good development methodology should outlive any particular tool. A three-phase adaptive workflow At its heart, AI-DLC organizes work into three phases that mirror how thoughtful software actually gets built. The Inception phase answers what to build and why . This is where the agent does requirements analysis, creates user stories when they're warranted, sketches the application design, breaks work into units that can be built in parallel, and assesses risk and complexity before a line of code is written. The Construction phase

Half a year ago, I wanted to see for myself what can we currently have with local LLMs. I went down the rabbit hole, learned quite a lot in the process, and shared my results in an article . The results were pretty discouraging: even with 32 GB VRAM, the best models I could run were both too slow and too dumb. At the same time, what you could get for free from inference providers was actually decent - and much faster. I remember my conclusion: "Let's wait for the next generation of models, which looks very promising. If we can run something comparable to full-size Qwen3-Coder-480B locally, that would be year of the Linux Desktop age of fully capable local LLMs. And now this day has arrived. Models Half a year later, I'm revisiting this question. And this time, the whole situation has turned upside-down. Almost none of the providers still have free tier, and anything that's still free is barely good enough even for the simplest tasks. And is rate-limited all over. And on the local side, the next Qwen lineup is out. So, that's what I'm going to be looking at. Once again, I have two RX6800's, 16 GB each, and 64 GB RAM. On one hand, this is more VRAM than any "normal person" can have with one GPU - unless you've got something specifically for AI, like an unified-memory Mac or a DGX Spark. On the other hand, RX6800 is "pre-AI" - anything newer will have much better performance thanks to tensor processors. Qwen3.6-27B : This is a dense model, so basically you can't run it at all on anything less than 32 GB VRAM. It's the slowest one, but also the best one if you can run it. Its accuracy is claimed to be on par with Claude 4.5 Opus, and better than Qwen3.5-397B-A17B . This is what I've been waiting for. It runs reasonably fast on my setup, so it's very much usable both in terms of performance and accuracy. Qwen3.6-35B-A3B : This one is MoE, and it's pretty small, so it's the fastest one. It's good for anything that doesn't require too much (i.e. for agentic tasks that don'

This week, researchers at the University of Minnesota announced something that genuinely stopped me mid-scroll. A team led by Associate Professors Kate Adamala and Aaron Engelhart built the world's first synthetic cell with a complete life cycle — not modified from an existing organism, not borrowed from biology. Built. From. Scratch. They're calling it SpudCell . It can grow. It feeds. It copies its own genetic material. It divides into new cells. And it does all of this from a starting point of pure chemistry — non-living components assembled with intent. Adamala put it plainly: "We've replicated in chemistry what only used to be possible in biology: the complete set of behaviors of a cell. It proves that the most fundamental functions of life, like growth and replication, do not need a mysterious magical spark." — University of Minnesota That's not hype. That's a scientist who has spent her career working toward this moment, choosing her words carefully. What SpudCell Actually Is SpudCell isn't a copy of a bacterium or a stripped-down version of an existing cell. It's a chemically defined system — meaning researchers know the full ingredient list, every molecule at every concentration. To put the scale in perspective: the human genome runs about 3 billion base pairs. SpudCell's genome is 90 kilobase pairs. Minimal by design. But minimal doesn't mean simple — it means precise . Every component earns its place. — CBS Minnesota The cell mostly resembles a basic bacterium in its behavior, but it carries none of evolution's baggage. No millions of years of accumulated quirks. No legacy code. Just the essential machinery for life's core functions, assembled on purpose. Yuval Elani, a synthetic biology researcher at Imperial College London, framed it this way: "Building a cell from scratch means you are no longer tied to the constraints and evolutionary baggage of natural biology. It opens up the possibility of designing systems and programming them to do things that li

I've been trying to learn coding for 35 years, which is my age. I love coding, and love the fantasy of being a coder. I love the whole thing about it. It's not a unhinged passion, but still something I carry very close to my digital heart. I started with VB6, and excel, and then web and I have never been particularly good at anything. If you ever met someone that loves gaming or sports but are bad at them, that's me. I need to have coding in my life, I'm just not good enough, ever. And that's fine. I discovered vibe coding because I follow all tech stuff. I've been trying to build certain things for years. I'm not necessarily desperate to build them but I do want them. Discovering AI allowed me to build personal web apps I always wanted to but was limited. All of the sudden I was able to build all web apps I wanted. I did 8 different projects in weeks. None of these things were for everyone, but very specific, tailored apps that help me at work, and in my personal life. Kinda trivializes the unbelievably fucking hard thing that is to learn evem the most remote thing about coding. Ive quit so many times becase concepts and terms I don't get. I still don't know what the fuck a prototype is in JavaScript even tho I got the certificate from FCC. Yet here I am building things that not even my imagination could put together. Am I enjoying it? Yes. Has it been beneficial? Fuck yes. I have been given the tools to create things my skills can't help me to. At the same time, as a person that have been trying to learn since I'm like 15, I know this isn't something to be trivialized. But at the same time I do have tools that trivializes it and they're available and free and works. Am I a disgusting person for feeling empowered? This is the first time in my journey I'm able to build actual things with the help of thear tools, but I also feel it's so disrespectful because I struggled for ALL MY LIFE trying to learn it. That said, since I stated vibe coding I've learn so many shit

The Quest Begins (The "Why") I still remember the first time I faced a problem that asked for the sum of numbers in a sub‑array, over and over again, with updates sprinkled in between. It felt like I was stuck in a never‑ending loop of for i in range(l, r+1): total += arr[i] – O(n) per query, and with up to 10⁵ queries the solution timed out every single time. I was staring at the screen, thinking, “There has to be a smarter way to answer these range questions without scanning the whole array each time.” That moment was my dragon: a seemingly simple problem that kept biting me because I kept reaching for the brute‑force sword. I needed a data structure that could give me the answer in logarithmic time while still supporting point updates. Enter the segment tree – the tool that turned my O(n·q) nightmare into an O((n+q)·log n) victory. The Revelation (The Insight) So why does a segment tree work? Imagine you have an array and you want to know the sum of any interval [l, r] . If you could break that interval into a handful of pre‑computed chunks, you’d only need to add those chunk values together instead of touching every element. A segment tree is exactly that: a binary tree where each node stores the aggregate (sum, min, max, etc.) of a segment of the original array. The root covers the whole array [0, n‑1] . Its two children cover the left half and the right half, and this keeps splitting until the leaves represent single elements. The magic lies in two facts: Every node’s value is a function of its children. If you know the sum of the left child and the sum of the right child, the parent’s sum is just their addition. This means we can build the tree bottom‑up in O(n) time. Any interval can be represented as O(log n) disjoint nodes. When you walk down the tree to answer [l, r] , you either take a whole node (if its segment lies completely inside the query) or you recurse further. Because the tree’s height is log₂n, you’ll visit at most 2·log₂n nodes. Thus, building

I’ve always thought building a mobile app required climbing a massive learning curve just to get a basic environment set up. To test that theory, I tried building my very first Android app using Google AI Studio . Five minutes later, I had a working prototype. The coolest part about this isn't just the speed: it’s that anyone can do this. The traditional barriers to building software are disappearing, making it incredibly easy to just start creating. I recorded the whole 5-minute process here if you want to see what it looks like in practice: What's in the video Prompting AI Studio to build a native Android app from scratch Progressive Webapp (PWA) vs Android Native App in 2026: feature comparison Sideloading the app onto an Android device via USB-C cable. No Play Store required What happens when the AI gets something wrong? Fixing bugs in a vibe coded app

As of May 2026, more than 80% of the code Anthropic ships is written by Claude, not by its human engineers. The company disclosed the figure in an essay called When AI builds itself , with coverage from Tom's Hardware and VentureBeat . Key facts What: Anthropic says more than 80 percent of the code it ships is now written by its own model, Claude, and the more interesting numbers are about judgment. When: 2026-06-23 Primary source: read the source Two years ago this share sat in the low single digits. The shift accelerated after Anthropic released Claude Code , a tool that lets the model read an entire codebase, make changes, run tests, and fix what breaks without human help. The human role has flipped: engineers used to author the code while the machine assisted; now the machine authors the code and engineers review, approve, reject, and steer. Anthropic reports its typical engineer ships roughly eight times as much code per quarter as a few years ago — not because people type faster, but because they spend their day reviewing the model's output instead of writing from scratch. Think of it as a newsroom where a tireless junior writer drafts every article and senior editors only sign off. Volume goes way up. But the 80% figure is less impressive than it sounds: a draft that a human must check, fix, and approve is not the same as a writer you can leave unsupervised. Most of those lines still pass through a person. On its own, this number measures effort the machine saves, not work it can be trusted to do without oversight. The results buried deeper in the essay matter more, because they concern taste rather than volume. Anthropic ran a recurring test where the model chooses the best next step in a research project, then compared its choices against its own scientists. Late last year the model was roughly a coin flip against the humans. By spring 2026, an unreleased internal model was picking the better direction clearly more often than its own researchers. Choosing w

Seriously, LeetCode in 2026? Everyone is saying HackerRank just killed LeetCode, and yet here I am,...

My learning so far I absolutely love learning to code. I gave it up to vibe code earlier last year and completely regret it. At first it felt like I was moving faster, but over time I realized I was skipping the part that actually made me better. My learning journey is fueled by passion and the hopes to move into a Go/SWE/Cloud type role. I do not know exactly how I will go about doing so, but I will work until I am noticed. Right now I am trying to focus on building real understanding. Not just getting something to work, but knowing why it works. I want to be able to read errors, debug my own code, understand the tools I am using, and slowly become the kind of developer that can solve problems without panicking. Learn to code! If anyone has any doubts on if coding is "worth it" still, I can account for how personally fulfilling it is. Solving a bug/problem in your own code gives me a personal high. There is something different about struggling with something, walking away, coming back, and finally seeing it click. It reminds you that you are actually learning. Every small fix feels like proof that you are getting better. I am not against using tools or AI. I still think they can be helpful. But I do think there is a big difference between using them to learn and using them to avoid learning. I had to learn that the hard way. So if you are new, or if you stopped for a while like I did, I really think you should keep going. Build small things. Break stuff. Fix it. Read docs even when they are boring. Ask questions. Take notes. Let yourself be bad at it for a while. I do not know where this journey will take me yet, but I know I want to keep showing up.

As the AI Engineer World's Fair Expo kicked off, a group of scientists gathered for an informal...

VCs remain thirsty to fund AI coding startups. This one, founded by investor Chamath Palihapitiya, is no exception.

Cursor has launched a new mobile app for remote oversight over coding agents.

Why Semantic HTML is a Superpower for Your Website As I’ve been building my personal portfolio during the IYF Season 11 program, I realized that writing code is about more than just making things look "right"—it’s about making them accessible for everyone. The secret is Semantic HTML. What is Semantic HTML? Semantic HTML uses tags that provide meaning to the web page rather than just layout instructions. Tags like , , , , and tell the browser and screen readers exactly what content they are interacting with. If you use for everything, you are handing a screen reader a blank map. Semantic tags act like a GPS, allowing users with visual impairments to navigate your site efficiently. Before vs. After The difference is clear when comparing structure: Before (Non-Semantic): HTML My Portfolio Home | About | Contact Welcome to my site... After (Semantic): HTML My Portfolio Home About Contact Welcome to my site... Fixing Accessibility Issues During my accessibility audit (Task 2.3), I identified three key areas to improve: Missing alt Attributes: I had images without descriptions. I fixed this by adding context, such as alt="Portrait of Gladwell Muthoni, web development student", ensuring screen readers can describe images to visually impaired users. Lack of Semantic Structure: My initial gallery relied on generic containers. Switching to and tags organized my project list logically, helping assistive technology categorize the content. Heading Hierarchy: I was using tags for visual styling rather than logical structure. I corrected this to follow a strict to hierarchy, which helps screen readers outline the page properly. My portfolios URL https://github.com/gladwellmuthoni/iyf-s11-week-01-gladwellmuthoni.git

I had arrived at the final frontier. My bare-metal kernel was booting in QEMU, driving NVMe block storage, running multi-agent swarms, and rendering a force-directed canvas. But to make V.E.L.O.C.I.T.Y.-OS a truly next-generation system, I needed to close the loop: the operating system had to be able to evolve and compile itself without human intervention. The V.E.L.O.C.I.T.Y.-OS 12-Part Roadmap We are building a bare-metal, self-healing operating system running entirely inside the CPU's L3 cache. Here is the roadmap for this 12-part series: Part 1: The Spark — Exposing the "Safe-Room" security leak and building the compiler gate. Part 2: The NDA Language — Designing a content-addressed triplet representation to cure context bloat. Part 3: Ditching the Web Stack — Building a native 30MB IDE with 1,500,000x IPC latency drops. Part 4: The Closure JIT — Compiling AST blocks to nested closures and bypassing borrow checker limits. Part 5: JIT Math Optimizations — Replacing division operations with precomputed 16-bit lookup tables. Part 6: x86-64 Assembler & SCEV-Lite — Compiling scalar loops directly to native code in constant time. Part 7: Classic Compiler Passes — Implementing inter-procedural Dead Code Elimination and loop unrolling. Part 8: Reclaiming Ring 0 — Exiting UEFI boot services and transitioning the kernel to Ring 0. Part 9: Bare-Metal Drivers — Writing a PCI scanner, NVMe block storage controller, and FAT32 parser. Part 10: Synaptic Canvas — Rendering a spatial, force-directed GUI based on model token activation vectors. Part 11: Swarms & Hot-Patching — Building multi-agent scheduling and zero-downtime RCU driver updates. Part 12: Self-Evolution — Handing system control over to a local LLM Terminal that self-optimizes via telemetry. (You are here) During the final hours of my Sunday morning sprint, I completed the self-healing loop, the Biosphere P2P registry, and the Boot-to-NDA LLM Terminal handover. To achieve self-healing, I built a Ring 0 telemetry sys