Claude writes about 90 percent of Claude Code’s own code. So who reads it? Mostly, other copies of Claude. And the result, by Anthropic’s account, is not chaos: from June to September 2026, merged pull requests to Claude Code’s codebase more than doubled, while the share that had to be reverted fell by more than 40 percent.
That comes from “How the Claude Code team does code review”, published on October 15, 2026 by Addy Osmani, Morgan Westlee Lunt and Qing Wang. It is Anthropic describing its own team with its own numbers, so treat it as a self-report. It is still the most detailed public look yet at what code review becomes when agents write most of the code.
“We didn’t remove review. But we did move most of the reading to machines, optimized for human time and attention, and invested heavily in making it fast and easy to undo mistakes.”
The flood
The pressure is easy to see in one number from Anthropic’s monorepo: changes landing per day went from about 2,500 in May to more than 30,000 in September. Claude Code lives in its own repository, but it feels the same squeeze. At that pace, line-by-line human review is, in the authors’ words, “incredibly difficult if not impossible.”
So the team stopped asking “did a human read the code?” and started asking what could go wrong with a change, and which check, automated or human, is the right one to catch it.
The new goal: spend humans carefully
The scarce resource is no longer code. It is human time and attention. The stated target is that most pull requests in the Claude Code repos (CLI, desktop, web and mobile apps) merge with at most one human in the loop, and that human can be the author.
The guardrail is what keeps this honest. Revert and incident rates must not rise. If they do, the team hasn’t saved human time, it has only moved it from reviewing to firefighting.
Review also stopped being a gate at the end. It now runs continuously, “more like spellcheck while you write.” Most changes have been reviewed and fixed by Claude at least once before any person is asked to look.
Seven layers, not one gate
A typical change passes through a stack of checks, each catching some problems and missing others:
- Self-verification. Claude has to run something (tests, a build, a screenshot compared to the design) and show the output instead of just saying it’s done. A fresh-context subagent then reviews the diff. Boris Cherny, who created Claude Code, estimates that giving Claude a way to verify its work makes the result two to three times better.
- AI review on every PR. Several agents hunt for bugs in parallel, then a separate group votes on each finding, and only findings enough of them agree on get posted. Every finding must be fixed or resolved with a reason.
- Security review that can block. No merge while any bug or security finding is open.
- Classic CI. Lint, type checks, tests on every platform, a build. A typical CLI pull request may run dozens of checks before anyone looks.
- Human approval scaled by risk (more below).
- Merge queue, flags and staged releases. New behavior usually ships behind a flag to Anthropic employees first.
- Fast detection and rollback. Flags turn off without a deploy, and a weekly on-call rotation asks which layer should have caught each incident.
When Anthropic launched its AI reviewer in research preview, the share of internal PRs getting substantive review comments jumped from 16% to 54%. The public version, Code Review for Claude Code, is generally available on Team and Enterprise plans.
Who still needs a human
Risk decides, not the author:
| Risk | Examples | Human approvals |
|---|---|---|
| Low | Docs, copy, internal-only features, additive changes behind a flag | None, once automated and security checks are green |
| Medium | Ordinary product changes, plus sensitive areas like caching, the auto-updater, system prompts | One |
| High | The highest-risk code and paths that always need two people | Two |
A classifier assigns the tier, and a second one asks whether a specific change needs a person anyway. Anything owners have listed as sensitive, and any CI workflow file, always needs a person. Only trusted authors, mostly the owning team, get the lighter paths.
Two rules stand out. An agent’s approval never counts as a person’s. And on an agent-written PR, the human who directed the agent is one of the required reviewers, as if they had typed the code themselves.
When robots review robots
The most striking part of the post is about what went wrong. An agent author and an agent reviewer can keep each other busy forever. One CLI pull request went through more than fifty rounds of review and fixes overnight before its author stopped it.
When the team ran git blame on what the reviewer kept flagging, about 59% was code that had been there since the reviewer’s first pass. It wasn’t finding new bugs. It was finding a few more old ones each round. Noise also costs more with an agent author: a person waves off a nit in seconds, while an agent “fixes” it, triggering another commit and another review.
The fixes:
- A round cap. After three rounds, the reviewer tells the author to step back and rethink the approach.
- Diff-only re-review after the first few passes.
- Flag the class of bug, so every instance gets fixed, not one line.
- No repeats of findings already posted.
The reviewer itself is graded daily against an eval set built from past PRs that caused incidents or reverts. Its priority, written down, is catching real bugs first and cutting review rounds second.
Speed over caution
One colleague put the philosophy bluntly: slowing down does lower your error rate, but mostly because you’re doing less of everything. Instead of slowing down, the team invests in noticing and undoing mistakes quickly. The norm is “you land it, you own it”: small changes, everything reversible, regressions caught through telemetry and heavy internal use, and incident reviews that look at the system rather than blame a person. The authors admit one gap: there are no circuit breakers yet that automatically tighten approvals when revert or incident numbers move, and engineers want them before more code goes to zero-human merges.
What humans still do
“Pulling a senior engineer out of deep work to catch a routine mistake costs far more than an automated review.”
So people now focus on deciding whether something should be built at all, reviewing risky code and architecture that others will copy, reading the evidence the checks produce, and owning the outcome. A person is accountable for every change that ships, whoever typed it.
Code review’s other job, spreading knowledge of the codebase, got a surprising answer. Nobody on the team keeps a full mental model of Claude Code, and they don’t think anyone needs to. When someone needs to understand a part of it, they ask Claude for an explainer of that exact slice, which takes minutes and reflects the code as it is today.
Why it matters
The old question was whether a human looked at every line. Anthropic’s answer is that this was always a proxy, and a weak one at agent scale. The real question is how much human attention each change needs to stay safe, and how fast you can undo it when something slips through. Approving a pull request in Anthropic’s public product is still a human call. Inside its own repos, the line of what can merge on automated checks alone keeps moving.
Sources:
- Anthropic (claude.dev Blog), How the Claude Code team does code review, October 15, 2026
- Code Review for Claude Code documentation
- Anthropic, Claude Code best practices
- Claude Code security review GitHub Action
