Anthropic merged about 2,500 code changes a day in May. By September it was over 30,000. The same post says what happened to the people reading them: “Our team members still review every change request for the system, but they now examine the intent of the change as opposed to reading every line of code.”
That sentence describes one internal system, not company policy. But it is a clean marker of where the industry is going. The person who used to read the diff now reads a summary of what the diff is for.

Most of the commentary treats this as a decline. Developers used to read every line, the story goes, and now they rubber-stamp. I went looking for the evidence, and the story is half right. Review is thinning, and the numbers are ugly. But the golden age it is supposed to be falling from was never what people remember.
Where the speed goes
Writing code got cheap, so the bottleneck moved downstream. An NBER working paper that tracked developers through three generations of tools found that autocomplete, interactive agents and autonomous agents raised commits by 30%, 180% and 240%. Then the gains shrank: “the 240% cumulative effect falls to 80% for the number of projects, and to 30% for actual releases.” The authors blame “human bottlenecks in the production chain”, not review in particular. Review is the obvious suspect.
| Measure | Value |
|---|---|
| Commits | +240% |
| Projects | +80% |
| Releases | +30% |
Source: Autonomous-agent effect in the NBER working paper w35275 (revised September 2026). Reported figures, not calculated.
LinearB measured the queue directly across 8.1 million pull requests. At the 75th percentile, a pull request written by an agent waits 17.6 hours before a human opens it. An unassisted one waits 3.4. Only 32.7% of the AI-generated ones merge within 30 days, against 84.4% of the others. LinearB sells engineering analytics, so treat these as a vendor’s numbers, but the direction matches everything else.
| Measure | Review time | Wait for a reviewer |
|---|---|---|
| Agentic | 6.4 h | 17.6 h |
| AI-assisted | 3.2 h | 8.3 h |
| Unassisted | 4.2 h | 3.4 h |
Source: LinearB, AI in software development report (8.1 million pull requests). Vendor-run. Wait and review times are separate percentile figures, not the same pull requests.
The skim is real
Faros AI analysed about 22,000 developers and reported that “31.3% more PRs are being merged without any review.” That is a rise in the count, not 31% of all pull requests, which several summaries got wrong. In the same data, median time in review rose 441.5%. LinearB adds a worse detail: “the largest changes receive the least review time.”
Anthropic’s own launch post for its AI reviewer admits the skim in plain words: “many PRs get skims rather than deep reads.” Before the tool, 16% of their pull requests got substantive comments. After, 54% did.

Simon Willison, who has written more about agentic coding than almost anyone, said it in the first person in May: “I’m not reviewing every line of code that they write anymore, even for my production level stuff.” He also warns about “normalization of deviance”: every time the agent gets it right, skipping the read feels safer, right up to the time it doesn’t.
Stack Overflow’s 2026 survey shows how developers actually check AI output. Most run it. Few ask another person.
| Measure | Value |
|---|---|
| Run it locally | 76.5% |
| Compare with the existing codebase | 63.9% |
| Inspect tests or security results | 53.0% |
| Use it as-is | 9.6% |
| Ask a coworker | 6.9% |
Source: Stack Overflow Developer Survey 2026, AI section (n = 13,162). Highlighted rows involve another person or no check at all.
Did people ever read every line?
Google’s reviewer guide says to “look at every line of code that you have been assigned to review.” It also lets you skim generated code and data files. So the norm existed, written down, in the most disciplined engineering shop in the industry.

What did the reading produce? Bacchelli and Bird studied review at Microsoft in 2013 and found it was “less about defects than expected.” What reviews delivered was “knowledge transfer, increased team awareness, and creation of alternative solutions.” Of the 570 comments they classified, 78, or 14%, were about defects. Google’s own case study, five years later, says the foremost reason it introduced review was “to improve code understandability and maintainability.” The median change was 24 lines.
Review was never mainly a bug filter. It was how a team found out what its own code did.
I have sat in review queues where a careful reader caught the off-by-one that tests missed. It happens. But the research says that is the minority of what the practice delivered, and it is the part that tests, types and an AI first pass handle better at the volume agents produce.
What we will actually miss
If bug-hunting is the part that automates well, what is left is the part nobody measured: spreading an understanding of the code across the people who must maintain it. An agent that writes 30,000 changes a day does not leave behind a team that understands them. Sonar called the result a verification gap: 96% of developers did not fully trust AI-generated code but only 48% said they always check it before committing. I think the deeper cost is comprehension debt: code that works and that nobody can explain.
Willison puts the symptom plainly. Asked whether software built this way is as good as software built by hand, he says: “I don’t know. I can’t tell from looking at it.”
Our take: review the intent, and make the author prove it
I think review splits in two, and teams that name the split will do better than those that drift into it.
- Review intent, not lines. The human reads the description, the tests and the risk, which is what Anthropic says it now does for its source-control system. Lines get read where the blast radius is high: auth, money, data deletion, migrations.
- The author attaches proof. A transcript of the change running, plus a test that fails if the change is reverted. This is Willison’s rule for agent-written code, and it moves the burden of evidence to the party that has the context.
- An AI reads first, and a human still approves. Anthropic runs its reviewer on nearly every pull request and says it “won’t approve PRs”: that stays a human call. Keep AI suggestions in front of the author. In Meta’s trial of AI-suggested fixes for review comments, reviewers who saw the patches took over 5% longer, and showing them only to authors removed the regression.
- Cap the size. Reviewers cannot hold a 1,000-line agent diff in their head. Google’s data has a median of 24 lines for a reason.
- Track the queue like any other metric. Pickup time and review time, split by who wrote the change. If agent PRs wait 17.6 hours, the team has a staffing problem it has not named.
DORA, Google’s research group, says the same thing from the other side. It points out that AI lets an author “generate a massive changelist” while “the reviewer is still expected to manually audit every single line,” and suggests teams “question if traditional asynchronous code reviews are still optimal,” with test automation likely to “provide a better return on investment than optimizing manual reviews.”
Two caveats. Anthropic’s 12x is the extreme case: GitHub’s Octoverse 2025 puts platform-wide merged pull requests at 43.2 million a month, up 23% on the year. And where review still happens it is getting longer, not shorter, which means “everyone skims” is too strong. What is true is that the team that reads every diff and the team that reads none are now both common, and the gap between them will show up in the incident log.
My own habit, for what it is worth: I read the tests first. If the tests are wrong or missing, I do not need to read the code yet.
References
- Redesigning source control at Anthropic Anthropic Engineering, 13 October 2026.
- Code Review for Claude Code Anthropic, 9 March 2026.
- Writing code vs. shipping code: productivity effects across generations of AI coding tools (w35275) NBER, revised September 2026.
- AI in software development LinearB.
- AI Engineering Report 2026: The Acceleration Whiplash Faros AI, 2026.
- Sonar Data Reveals Critical "Verification Gap" in AI Coding: 96% Don't Fully Trust Output, Yet Only 48% Verify It Sonar, 8 January 2026.
- Stack Overflow Developer Survey 2026: AI Stack Overflow, 6 October 2026.
- Balancing AI tensions: moving from AI adoption to effective SDLC use DORA (Google), 10 March 2026.
- Vibe coding and agentic engineering are getting closer than I’d like Simon Willison, 6 May 2026.
- Expectations, outcomes, and challenges of modern code review Bacchelli and Bird, ICSE, 2013.
- Modern code review: a case study at Google ICSE-SEIP, 2018.
- What to look for in a code review Google Engineering Practices.
- AI-assisted fixes to code review comments at scale arXiv, 2025.
- Octoverse 2025: a new developer joins GitHub every second as AI leads TypeScript to #1 GitHub, 28 October 2025.
- Your job is to deliver code you have proven to work Simon Willison, 18 December 2025.