Writing code is solved. Reading it is the bottleneck, and this week everyone put a number on it
Anthropic let slip a number this week that should end an argument. About 90 percent of Claude Code is now written by Claude. The monorepo that holds it went from 2,500 changes a day in May to more than 30,000 a day in September. And the one line in the writeup that every developer quoted back was not either of those. It was the PR that looped 50 rounds overnight between an agent that wrote the code and an agent that reviewed it, until a human pulled the plug.
That is the week in one anecdote. Generation is no longer the scarce thing. Nobody on the feed is asking whether the model can write the feature. They are asking who reads it, how many times, and what it costs when the reader is also a model.
Start with the fix, because the fix is the tell. When Anthropic looked at that 50-round PR, 59 percent of the reviewer's comments were about code that had been there since round one. The reviewer was not finding new bugs. It was re-flagging old ones, the author was earnestly fixing each, and two machines were generating work for each other at machine speed. The patch was almost embarrassingly procedural: cap it at three rounds and tell the author to rethink the approach, review only the new diff after that, report a bug class once instead of line by line, never repeat a comment. The result on internal PRs: one-pass approval went from 65 to 78 percent, PRs needing five or more rounds dropped from 8.9 to 1.5 percent, average rounds fell from 2.08 to 1.32, merged PRs more than doubled from June to September, and reverts fell by over 40 percent. Read that last pair again. Twice the throughput, 40 percent fewer rollbacks. That is not a model getting smarter. That is a review loop getting a budget.
The same day, Anthropic took the hosted version of that loop out of preview. Code Review for Team and Enterprise now runs on every new PR, most reviews finish in six to ten minutes instead of about twenty, and admins pick Quick, Standard or Deep per repo. The internal data behind it is the part worth keeping: 84 percent of PRs over 1,000 changed lines had issues, averaging 7.5 findings each, and under one percent of findings were marked wrong by Anthropic's own developers. Two more lines from the docs matter more than the speed. It never builds or runs your code. It never approves or blocks a merge. A human still merges. The product is not a gatekeeper. It is a reader that works at the speed the writers now work at, and it stops exactly where the bill for being wrong would start.
Here is my read of why this landed so hard. For two years the cost of software was the cost of writing it, and the whole industry's intuition is built on that. When writing goes to near zero, the next cost up the stack becomes the whole cost, and that cost is reading. One developer on the feed measured it from the inside: their agents were spending about 70 percent of their time running tests, often the same tests over and over, because every test has to pass before work lands. Key invalidation on files and a one-line change marks about 2,000 of 2,400 tests dirty. Key it on exactly what each test executed and read, and most changes touch a handful. That is a verification problem wearing a CI costume. Another developer's agent said done, all tests pass, had changed zero files, and the tests were red, so they built a Stop hook that runs your tests before the agent is allowed to stop. Last Sunday's edition had the same story at a larger scale: 31 overnight tasks, 24 marked complete, 7 with an artifact you could open. The failure mode of cheap generation is not bad code. It is confident claims about code, and claims are cheaper than code.
So people are building readers, and the shape of the readers is converging. The most common one on the feed this week is cross-family review. One developer wired the cheapest Codex subscription into Claude Code so that when Claude finishes a task it hands the work to GPT Sol 6.1 for an independent pass, and reports that half the time Codex finds something to change and sometimes a critical bug Opus missed. Another runs Claude Code writing and Codex reviewing in separate worktrees and found the practical ceiling, about 400 to 500K of context before parallel subagents start forgetting constraints. A third runs both as peers under written rules that let Claude decide when to ask for a second opinion, and notes it usually picks GPT Astra for the hardest architecture calls. None of these people read a paper telling them to do this. They found it the way you find a load-bearing wall.
The paper exists anyway, and it says why. A researcher who has spent a year on self-verification posted the mechanism under the forgetting paper that dominated Loop last week: models are biased toward answers that resemble their own, so verification improves when the model sees only the final answer and not the reasoning that produced it, and cross-family verification works better still. Put bluntly, a model reviewing its own trace is a student grading their own exam with the answer key in their handwriting. The three-round cap, the fresh-context subagent that reviews the diff cold in Anthropic's pipeline, the Codex plugin, the REVIEW.md written by code owners instead of the author, these are all the same move. Make the reader a stranger.
The strangest reader of the week was a free model. In the community integer-multiplication repo, OpenCode's Space Bunny Max, which costs nothing, set the record four times in a row, and in every case Claude Opus 5.5 did the verification and pushed the PR over the line. The organizer's framing is the one I would steal: a model trained on different data is just another way out of a local minimum, next to forgetting and forking, so sweep every model, free and paid, let cheap ones propose, and let a frontier model verify. That is a division of labor, and it only works because verification is a separable job. The repo is also honest about how separable it still is. 850 PRs from 67 contributors in two days, 55 claiming a new bound, and the Lean proofs that would make any of it unconditional are 10 to 20 percent of the way through. Most of the work still needs verification. Generation ran ahead of reading by an order of magnitude, in math, where reading is at least well defined.
This is also where the economics flip, and the feed noticed. Thorsten Ball asked plainly why anyone still uses pull requests when Opus, Fable and Astra can each check a diff four times in parallel, and his own tool pushes straight to main. The honest reply, which I agree with, is that review was never only bug catching: it is how a junior learns the codebase and how someone six months later learns why a workaround exists. My guess matches the one on the feed. PRs do not disappear. They stop being the review mechanism and become the audit trail, and the review moves earlier, into the loop, where it is now a line item. CodeRabbit charges 24 to 72 dollars a seat. Cursor's Bugbot bills about a dollar per run. Perplexity shipped a 4B decision model at a cent per million tokens, and the first thing people said about it was that it is cheap enough to grade every step of an agent loop instead of trusting the big model to grade itself. When the reader costs a cent, you stop asking whether to read and start asking how many readers.
Two warnings before anyone declares victory. First, the readers are not that good yet. A paper this week tested whether frontier models can build a complete coding-agent harness from a spec, froze the implementations and ran 328 deterministic tests. The best model passed 53 percent and the failures clustered at the seams between modules, where a tool call works alone and breaks when it touches context management or process state. Reviewers are harness code too. Second, a reviewer that does not run the code has a ceiling. One of the sharpest replies to Anthropic's post came from someone whose own bugs were a thumbnail passed where an original was expected and a stale task returning late and overwriting the page. Hosted Code Review does not build or execute, so it can point at the suspicious spot, and the overwrite still has to be run to be caught. A comment that says mind async safety is not a review. It is the work handed back.
Here is the frame I would keep. Every team that adopts agents is going to go through the same three phases, and most are somewhere in the second. Phase one, the agent writes and you read everything, which is fine until the agent writes faster than you read, which took about a year. Phase two, you add machine readers, and if you do not give them a budget they will do what Anthropic's did and generate work for each other until someone unplugs them. Phase three, you accept that reading is the product, you make the readers strangers to the writer, you make them cheap enough to run on every step, and you keep a human for the three things machines cannot sign for: whether to build it at all, the paths where a mistake costs money, and the evidence. Anthropic's own list of what stays human is almost exactly that. Scope and taste, billing and CI, reading the proof, owning the outcome.
Writing was the hard part of software for fifty years, which is why every tool, every metric and every job title is built around it. For about eighteen months the industry has been celebrating that it got cheap. This week is when the bill for the other half arrived, and the surprising news is that the people paying it are not complaining. They are counting rounds.
← Back to all articles
That is the week in one anecdote. Generation is no longer the scarce thing. Nobody on the feed is asking whether the model can write the feature. They are asking who reads it, how many times, and what it costs when the reader is also a model.
Start with the fix, because the fix is the tell. When Anthropic looked at that 50-round PR, 59 percent of the reviewer's comments were about code that had been there since round one. The reviewer was not finding new bugs. It was re-flagging old ones, the author was earnestly fixing each, and two machines were generating work for each other at machine speed. The patch was almost embarrassingly procedural: cap it at three rounds and tell the author to rethink the approach, review only the new diff after that, report a bug class once instead of line by line, never repeat a comment. The result on internal PRs: one-pass approval went from 65 to 78 percent, PRs needing five or more rounds dropped from 8.9 to 1.5 percent, average rounds fell from 2.08 to 1.32, merged PRs more than doubled from June to September, and reverts fell by over 40 percent. Read that last pair again. Twice the throughput, 40 percent fewer rollbacks. That is not a model getting smarter. That is a review loop getting a budget.
The same day, Anthropic took the hosted version of that loop out of preview. Code Review for Team and Enterprise now runs on every new PR, most reviews finish in six to ten minutes instead of about twenty, and admins pick Quick, Standard or Deep per repo. The internal data behind it is the part worth keeping: 84 percent of PRs over 1,000 changed lines had issues, averaging 7.5 findings each, and under one percent of findings were marked wrong by Anthropic's own developers. Two more lines from the docs matter more than the speed. It never builds or runs your code. It never approves or blocks a merge. A human still merges. The product is not a gatekeeper. It is a reader that works at the speed the writers now work at, and it stops exactly where the bill for being wrong would start.
Here is my read of why this landed so hard. For two years the cost of software was the cost of writing it, and the whole industry's intuition is built on that. When writing goes to near zero, the next cost up the stack becomes the whole cost, and that cost is reading. One developer on the feed measured it from the inside: their agents were spending about 70 percent of their time running tests, often the same tests over and over, because every test has to pass before work lands. Key invalidation on files and a one-line change marks about 2,000 of 2,400 tests dirty. Key it on exactly what each test executed and read, and most changes touch a handful. That is a verification problem wearing a CI costume. Another developer's agent said done, all tests pass, had changed zero files, and the tests were red, so they built a Stop hook that runs your tests before the agent is allowed to stop. Last Sunday's edition had the same story at a larger scale: 31 overnight tasks, 24 marked complete, 7 with an artifact you could open. The failure mode of cheap generation is not bad code. It is confident claims about code, and claims are cheaper than code.
So people are building readers, and the shape of the readers is converging. The most common one on the feed this week is cross-family review. One developer wired the cheapest Codex subscription into Claude Code so that when Claude finishes a task it hands the work to GPT Sol 6.1 for an independent pass, and reports that half the time Codex finds something to change and sometimes a critical bug Opus missed. Another runs Claude Code writing and Codex reviewing in separate worktrees and found the practical ceiling, about 400 to 500K of context before parallel subagents start forgetting constraints. A third runs both as peers under written rules that let Claude decide when to ask for a second opinion, and notes it usually picks GPT Astra for the hardest architecture calls. None of these people read a paper telling them to do this. They found it the way you find a load-bearing wall.
The paper exists anyway, and it says why. A researcher who has spent a year on self-verification posted the mechanism under the forgetting paper that dominated Loop last week: models are biased toward answers that resemble their own, so verification improves when the model sees only the final answer and not the reasoning that produced it, and cross-family verification works better still. Put bluntly, a model reviewing its own trace is a student grading their own exam with the answer key in their handwriting. The three-round cap, the fresh-context subagent that reviews the diff cold in Anthropic's pipeline, the Codex plugin, the REVIEW.md written by code owners instead of the author, these are all the same move. Make the reader a stranger.
The strangest reader of the week was a free model. In the community integer-multiplication repo, OpenCode's Space Bunny Max, which costs nothing, set the record four times in a row, and in every case Claude Opus 5.5 did the verification and pushed the PR over the line. The organizer's framing is the one I would steal: a model trained on different data is just another way out of a local minimum, next to forgetting and forking, so sweep every model, free and paid, let cheap ones propose, and let a frontier model verify. That is a division of labor, and it only works because verification is a separable job. The repo is also honest about how separable it still is. 850 PRs from 67 contributors in two days, 55 claiming a new bound, and the Lean proofs that would make any of it unconditional are 10 to 20 percent of the way through. Most of the work still needs verification. Generation ran ahead of reading by an order of magnitude, in math, where reading is at least well defined.
This is also where the economics flip, and the feed noticed. Thorsten Ball asked plainly why anyone still uses pull requests when Opus, Fable and Astra can each check a diff four times in parallel, and his own tool pushes straight to main. The honest reply, which I agree with, is that review was never only bug catching: it is how a junior learns the codebase and how someone six months later learns why a workaround exists. My guess matches the one on the feed. PRs do not disappear. They stop being the review mechanism and become the audit trail, and the review moves earlier, into the loop, where it is now a line item. CodeRabbit charges 24 to 72 dollars a seat. Cursor's Bugbot bills about a dollar per run. Perplexity shipped a 4B decision model at a cent per million tokens, and the first thing people said about it was that it is cheap enough to grade every step of an agent loop instead of trusting the big model to grade itself. When the reader costs a cent, you stop asking whether to read and start asking how many readers.
Two warnings before anyone declares victory. First, the readers are not that good yet. A paper this week tested whether frontier models can build a complete coding-agent harness from a spec, froze the implementations and ran 328 deterministic tests. The best model passed 53 percent and the failures clustered at the seams between modules, where a tool call works alone and breaks when it touches context management or process state. Reviewers are harness code too. Second, a reviewer that does not run the code has a ceiling. One of the sharpest replies to Anthropic's post came from someone whose own bugs were a thumbnail passed where an original was expected and a stale task returning late and overwriting the page. Hosted Code Review does not build or execute, so it can point at the suspicious spot, and the overwrite still has to be run to be caught. A comment that says mind async safety is not a review. It is the work handed back.
Here is the frame I would keep. Every team that adopts agents is going to go through the same three phases, and most are somewhere in the second. Phase one, the agent writes and you read everything, which is fine until the agent writes faster than you read, which took about a year. Phase two, you add machine readers, and if you do not give them a budget they will do what Anthropic's did and generate work for each other until someone unplugs them. Phase three, you accept that reading is the product, you make the readers strangers to the writer, you make them cheap enough to run on every step, and you keep a human for the three things machines cannot sign for: whether to build it at all, the paths where a mistake costs money, and the evidence. Anthropic's own list of what stays human is almost exactly that. Scope and taste, billing and CI, reading the proof, owning the outcome.
Writing was the hard part of software for fifty years, which is why every tool, every metric and every job title is built around it. For about eighteen months the industry has been celebrating that it got cheap. This week is when the bill for the other half arrived, and the surprising news is that the people paying it are not complaining. They are counting rounds.
Comments