The code that writes the code

Here's a number that should reframe how you think about coding agents. Anthropic now says more than 80% of the code merged into its own systems is written by Claude — up from the low single digits before Claude Code shipped in early 2025. The company that builds the model builds most of its software with the model.

And on June 5 it published a report on recursive self-improvement — AI that helps build the next, more capable AI — moving the idea out of thought-experiment territory and into a roadmap with stages and safety checkpoints. Axios summed up the warning bluntly: AI could soon help build its own successors.

You can take that as a scary headline. I'd rather take the part that's already true and useful.

The 80% is the real story

Forget the far end of the curve for a second. The fact on the ground is that a frontier lab — the people with the most context, the highest stakes, and the least patience for slop — ships the vast majority of its code through an agent. That's not a demo. That's a production practice at the place that knows the model best.

It tells you the question is no longer can an agent write the code. It can. The question is what that does to where your work lives.

When the agent writes the code, review becomes the job

If 80% of the code is generated, then 100% of your leverage moves to two places: what you ask for and how you check what comes back. The bottleneck stops being typing and becomes specification and verification.

That's been my whole working model for a while now. I don't write the code by hand; I direct agents and own the architecture, the spec, and the quality bar. And the thing that makes it work isn't a clever prompt — it's that I don't trust the output because it looks right. I verify it. The faster the agent produces code, the more the entire system depends on the strength of the check at the end.

This is why an eval mindset stops being a nice-to-have. When a human wrote every line slowly, the writing was the review. When an agent writes it in seconds, the review has to be deliberate, separate, and measured — or you're just merging plausible-looking code at high speed.

What "self-improving" should change in your habits

You don't need recursive self-improvement to land for the lesson to bite. Agents are already good enough that they generate far more than you can eyeball. So:

• Make the spec the artifact you sweat. The agent will faithfully build what you actually said. Vague spec, confident wrong code. Your precision is the product.
• Put a measured check between "generated" and "merged." Tests, evals, a second agent that reviews — something that produces a number, not a feeling, before code lands.
• Watch the rate, not just the output. If generation speed goes up and your verification stays manual, the gap is pure risk. Scale the checking with the writing.

The labs are automating the writing of their successors. The human job that doesn't automate away is deciding what should be built and proving that what got built is correct.

The bottom line

Anthropic writing 80% of its code with Claude isn't a future warning — it's a present description. The agent already writes the code. Recursive self-improvement just turns the dial further in the same direction.

As the writing gets automated, your leverage collapses onto the spec and the check. Sweat the specification, put a measured gate before merge, and scale verification as fast as generation. The code that writes the code still needs someone who can prove it's right.