How I code with AI

aiai-agentsdevtoolsspec-driven-devcareer

Anthropic published some numbers on how AI is speeding up its own development. Over 80 percent of their production code is now written by Claude, code output per engineer is up 8x since 2024, and the length of tasks an AI can finish on its own doubles every four months. It’s not just them either. GitHub saw about one billion commits in all of 2025. Right now it’s running at 275 million a week.

I can see it in my own work. I haven’t written a function by hand in weeks. I still have my IDEs installed, but I open them so rarely at this point that IntelliJ has to rebuild its cache every single time, and anyone who has sat through that knows exactly the pain I’m talking about. Most of what I ship starts with me telling a machine what I want, from my phone or in a shell.

The plan is the work

I always planned before coding, but the plans were rough. Implementation details never had to be spelled out, because I knew the codebase and I had the experience, and between the two of them the how would work itself out while I typed. An agent doesn’t bring any of that. What you hand over is a description, and a vague description gets you vague code back.

So how I start depends on the task now. Some days it’s TDD, I define the tests and the agent writes code against them until they pass. Bigger or riskier work gets a thorough plan upfront, what it should do, where it fits, what it’s not allowed to break, and then the agent writes its own implementation plan back to me before it touches anything and we go back and forth over it until I run out of objections. When the stakes are low I just vibe code. Let the agent go, follow its intuition, see where it lands.

The tooling supports all of it. Plan mode to write the spec, where the agent can read everything but change nothing. Goal mode to finish, where it runs until the feature is done. And loops that prompt the agents for me on a schedule, so the next task gets picked up and the queue keeps moving and the checks get rerun without me typing any of those prompts myself.

If the plan is mush, it doesn’t matter how smart the model is.

The fleet

I run five to ten Claude instances at once. Even that undersells it, because one instance isn’t one worker. Give it a big job and it fans out into hundreds of subagents, each working on its own piece and reporting back up, so what looks like ten agents is really ten managers with staff.

A lot of work splits up like this. Reviews that go through the whole diff from a dozen angles with a second wave checking whatever the first wave flagged, migrations where every file gets its own agent, reading a subsystem from a few directions at once, tests and specs across a big batch in one pass. I never did any of this before. Coordinating it by hand cost more than it was worth.

So what do I do all day? I keep the sessions open and round robin from one to another. I figure out what to ask for, I cut it into pieces an agent can finish, and I look at what comes back and decide whether it’s any good, which is most of the job and the one part there’s no handing off.

The agents run wherever it makes sense: my laptop, a Linux box in my basement, an EC2 instance, the ephemeral boxes Anthropic spins up and throws away. Even right now I have one of those ephemeral boxes open, and another agent is over on the EC2 instance working on a platform I built. I’m not typing code in either one. All of it runs in tmux over remote connections so the sessions survive me walking away. I covered that setup in I built a product from my phone.

Review and sign-off

When the work comes back, I review it. The first pass isn’t me though. Automated review runs on the diff before I even look, some of it /code-review, the bigger part a set of review skills I wrote myself, standards from years of doing this, written down so a machine applies them every single time:

  • The spec is the contract. Code that quietly does something the spec doesn’t say gets flagged, not merged.
  • If something can’t be undone, I want a good reason it isn’t a soft delete.
  • Keep the surface small. Don’t add the endpoint or the button if you don’t have to.
  • If it ships, it ships with the logs and metrics to debug it later.

I copied my own taste into something that checks the work for me, and what that buys me is that the boring stuff is already gone by the time I’m reading, so my attention goes to the questions that actually need a person. Is this the right approach. Does it fit the system, or just this corner of it. And is there a case nobody thought about.

The human is still in the loop, that part hasn’t changed. A person merges, and if it ships broken, “the agent wrote it” is not an excuse anyone gets to use. The merge is the one button in the loop I still press myself.

What the job is now

What’s left is the planning, the judgment, and the sign-off. The typing was the part that left.

The AI labs already have a name for this that fits better than “software engineer”: member of technical staff. It sounds like nothing, but it covers the spread, product and engineering and the infra the agents run on, plus the open problem of orchestrating all of it. I think that’s where at least some of this work is going.

How far this goes isn’t up to me. METR tracks how long a task an agent can finish on its own, and the line keeps doubling. That’s the curve to watch.