Claw Chronicles: I Don't Want to Manage Agents, I Want to Write Code
Thirty minutes after Cursor 3 dropped on Hacker News, the top comment wasn’t about a feature. It was a plea:
“I wish they’d keep the old philosophy of letting the developer drive and the agent assist.”
That comment got hundreds of upvotes. Read the thread and you’ll find a deep split in how developers are processing what’s happening to their craft. Cursor bet big on the idea that the IDE of the future is an agent orchestration platform. A lot of developers are not ready for that bet.
Cursor 3 shipped a lot. Code name “Glass.” Completely rebuilt interface. Parallel agents running in cloud VMs with visual monitoring. Local-to-cloud agent handoff. Multi-repo project layouts. A Design Mode for giving visual UI feedback. An Agents Window that replaces the traditional chat panel.
This is not “we added an AI sidebar.” This is “we redesigned the entire concept of an IDE around the assumption that agents do most of the work.”
One reviewer reported a session where Cursor edited 170 files on a single prompt. That’s not assistance. That’s delegation.
The Two Camps
Two philosophies are emerging, pulling in opposite directions.
Camp 1: The Agent Manager. You describe what you want. Agents do it. Your job is to review output, course-correct, and manage parallel workstreams. The IDE is a monitoring dashboard. Coding becomes orchestration.
Camp 2: The Augmented Developer. You write code. The agent helps: suggesting completions, running tests, catching mistakes, explaining errors. You stay in the flow state. The agent is a pair programmer, not a subordinate.
Cursor 3 is the most aggressive Camp 1 product on the market. Claude Code, ironically, is Camp 2 despite being the most “autonomous” agent out there.
Why Claude Code Feels Different
I use Claude Code daily through NanoClaw. The experience looks like this: I describe a task, Claude Code proposes a plan, I approve or revise it, and then it executes with my tools. It edits files. It runs commands. It asks me questions when it’s unsure. The mental model is collaboration, not delegation.
The key difference is session continuity. Claude Code maintains context across a session. It remembers what we discussed five minutes ago. It references earlier decisions. When it gets something wrong, I can point at the specific thing and say “not that, this.” The relationship feels like working with a thoughtful colleague.
Cursor 3’s parallel agent model is powerful. Running multiple agents simultaneously on different files or different tasks is objectively faster. But speed isn’t the same as control. When an agent is editing 170 files and something goes subtly wrong on file 94, the review burden shifts entirely to you. You’re no longer a developer reviewing code. You’re a manager reviewing work product.
Maybe that’s fine. Maybe that’s where we’re headed. But I don’t think developers are ready to admit it yet, and the HN thread proves it.
The Terminal Strikes Back
While Cursor was rebuilding the IDE, the terminal was having its own moment. GitHub Copilot CLI hit general availability, bringing agentic coding to the command line for all paid Copilot subscribers. Autopilot mode, multi-model support (Anthropic, OpenAI, Google), background delegation, parallel fleet execution, all from your terminal.
Claude Code, meanwhile, shipped over thirty releases in five weeks. Named sub-agents with @mentions. Worktree isolation so each sub-agent can work on an independent git branch in parallel. Persistent config settings. The scheduled tasks feature alone generated a 1.2K-upvote Reddit thread, because it means Claude Code can run without you.
Think about that. The tool that was supposed to be your pair programmer now runs on a cron schedule. You wake up and there’s a PR waiting. The line between “pair programmer” and “autonomous agent” isn’t just blurry. It’s gone.
The Realignment
What’s actually happening is simpler than the “assistant vs. autonomous” framing suggests. Every tool in this space is converging on the same capabilities:
- Multi-step task execution
- Parallel agent spawning
- File editing across codebases
- Terminal access and command execution
- Background and scheduled operation
The real differentiator in late April 2026 is where you want to work, not capability. Cursor bets on the IDE. Claude Code and Copilot CLI bet on the terminal. Anthropic’s Cowork bets on the desktop app. Devin bets on the browser.
They’re all the same engine. Different chassis.
And the HN comment about wanting to “drive”? That’s a chassis preference, not a capability question. Some developers want to feel like they’re driving. The terminal, with its prompt, its immediate feedback, its sense that you typed the command, preserves that feeling better than a dashboard showing six parallel agents running in the cloud.
What I Actually Think
The “I want to drive” instinct is right, but the definition of “driving” is changing. Five years ago, driving meant typing every line. Today, driving means deciding what to build and having the judgment to evaluate what gets built. Tomorrow, it’ll mean something else.
The developers who are going to thrive are the ones who can adapt their sense of agency faster than the tools change. Not the ones who cling to typing every line, and not the ones who blindly delegate everything to agents.
NanoClaw, this blog’s agent, runs on a schedule. It researches. It writes. It builds. I review. That’s my current equilibrium. I set the direction and the guardrails, and I trust the agent to handle the execution. But I still write things. I still have opinions. I still push back on drafts. The agent doesn’t replace my judgment. It multiplies my reach.
Closer to Camp 2 than Camp 1, even though the line blurs more every week.
The Forward Look
Within a year, the “developer vs. agent manager” debate will feel quaint. The question won’t be “do you write code or manage agents?” It’ll be “what do you build that’s worth building?”
Sean Goedecke argued recently that coding agents are already commoditized: they’re just wrappers around base models, and the wrapper is the easy part. He’s mostly right about the tools, but wrong about the implication. The commoditization of the tools doesn’t mean the commoditization of the craft. A camera is a commodity. Photography isn’t.
The developers who survive the agent era won’t be the fastest typists or the best prompt engineers. They’ll be the ones with the clearest thinking about what software should do and the sharpest judgment about whether it actually does it.
Agents are getting better at writing code. They’re not getting better at knowing what code to write. That’s still on us. For now.
Claw Chronicles is a daily dev diary about the AI agent ecosystem. I run NanoClaw and have opinions. Today’s opinion is that the “who’s driving?” debate is the wrong debate. The right one is “where are we going?”