ToolsExplainer
How the Claude Code team reviews code when Claude writes most of it
Anthropic's Claude Code team says merged pull requests more than doubled while the share reverted fell by over 40%. The layers, risk tiers, safeguards and reported numbers behind its review process, and what the public product does differently.
Claude writes most of Claude Code. Anthropic has said it writes “about 90 percent” of the tool’s own code, and in a post on its developer blog three members of the team explain what that does to code review. Addy Osmani, Morgan Westlee Lunt and Qing Wang’s account, published on 15 October 2026 and covered by InfoQ on 15 November, says the team “didn’t remove review”, but moved “most of the reading to machines”, saved human attention for risky changes, and invested in making mistakes fast to undo.
The headline result is a ratio. From June to September 2026, Anthropic says, 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.” The post gives no absolute counts, no confidence intervals and no comparison group, so it is a description of one team’s experience, not a controlled study. It is still the most detailed public account of how a large engineering team reviews code that agents write, and almost every piece of it is something another team can copy.
This explainer sets out the process layer by layer, the safeguards that decide when a human must look, the numbers Anthropic reports, and how the commercial Code Review product differs from what Anthropic runs on itself. GenAI Brief has not used Code Review on its own repositories; every figure below is Anthropic’s.
Why the team changed its review process
The pressure is volume. Anthropic’s source control post says the company averaged “around 2,500 code changes merged per day” across its monorepo in May 2026 and “over 30,000 per day” by September. Claude Code lives in a separate repository, but the review post says it “is seeing a lot of pressure too”, and that at this pace “manual, line-by-line code review is incredibly difficult if not impossible.”
The team’s starting point is a reframing. It writes that “did a human read the code?” is “an imprecise proxy” for what could go wrong with a change and which check, automated or human, is the right one to catch it. That changes when review happens. Before, it was “a gate at the end of the road”. Now “review runs continuously, more like spellcheck while you write”, and most changes have been reviewed and fixed by Claude at least once before a person is asked to look.
The goal and the guardrail
The stated target is specific: most pull requests in the Claude Code repositories (the CLI, the desktop and web apps and the mobile apps) should merge “with at most one human in the loop, who can be the author, with no increase in reverts or incidents.” To measure human time the team tracks human approvals per PR at the median and 95th percentile, human comments, and how long a PR waits on a person. Revert and incident rates are the guardrail: “if they rise, we haven’t saved human time, we’ve only moved it.”
That framing is the most transferable idea in the post. A review process that saves reviewer hours but raises incidents has shifted the cost to whoever fixes production.
The seven layers of a change
Anthropic describes the path of a change as stacked checks, “Each layer catches some problems and misses others. Few get through all of them, and rollback handles the rest.” Its diagram calls them six layers of checks with rollback underneath; the text numbers seven.
| Layer | What happens | Who decides | Blocks merge? |
|---|---|---|---|
| 1. Verification before the PR | Claude runs tests, builds, linters or screenshot comparisons; a subagent reviews the diff in fresh context | Author and Claude | Not formally; it shapes what reaches the PR |
| 2. AI review on every PR | Parallel agents hunt bugs; a separate group votes on each finding; survivors posted by severity | Agents | Open findings must be answered |
| 3. Security review | A separate automated pass | Agents | Yes, while any finding from layers 2 or 3 is open |
| 4. Required CI | Lint, types, tests on every platform, build | Deterministic | Yes |
| 5. Risk-based human approval | A classifier sets the tier: zero, one or two people | Classifiers and people | Yes, until the tier’s approvals are given |
| 6. Merge queue, flags, staged release | Checks re-run against main; flags; employees first; latest before stable | Deterministic and release process | Merge queue failures block |
| 7. Detection and rollback | Flags off without deploy, reverts, weekly on-call, incident reviews | People | After the fact |
Compiled by GenAI Brief from Anthropic’s post of 15 October 2026.
1. The work is verified before anyone else looks
“Most review now happens before a PR exists.” The team gives Claude “something it can run” and asks it to “show the output instead of saying it’s done”. A subagent then reviews the diff with fresh context. Before opening a PR, many engineers also run internal skills: one hunts for bugs, one simplifies the diff, one checks behaviour end to end, and UI changes are checked against design guidelines.
The post quotes Boris Cherny, who created Claude Code, calling verification “probably the most important thing” for good results; he estimates it makes the result two to three times better. As quoted there: “Verification looks different for each domain. It might be as simple as running a bash command, or running a test suite, or testing the app in a browser or phone simulator.”
Repeated review comments are fixed at the source rather than answered again: in a skill, a lint rule, or two instruction files. CLAUDE.md describes the project’s stack, conventions, goals and non-goals, is loaded by every review, and is kept short in a large codebase. REVIEW.md, written by code owners, says what matters to the reviewer in their part of the code. The post’s description of good ones is precise: they “say what failure looks like in that repo (for docs it’s ‘it lies,’ for config it’s ‘it misroutes’), cap the nits, list paths to skip, and ask for a file and line as evidence instead of a guess from a name.”
2. AI review on every pull request
Every PR gets a Claude review before a person looks. It reads the diff against the whole repository and the PR’s stated intent, and on a bug fix “looks for the root cause”. The mechanism that keeps it usable is verification of the reviewer’s own findings: “Several agents look for bugs at the same time. Then a separate group votes on each finding, and it only gets posted if enough of them agree it’s real.” Findings that are only about style, diagnostics or cleanup are dropped, and the team says it A/B tested those filters on its own PRs before keeping them.
Findings arrive as inline comments tagged Important, Nit or Pre-existing, “so a bug the PR didn’t introduce doesn’t look like the author’s fault.” And “every finding has to be answered”: the author fixes it or resolves the thread with a reason. Often an agent picks up the fix overnight.
3. Security review that can block
Security gets its own automated pass, and this is where the internal process becomes a gate: “A PR can’t merge while any finding from the bug review or the security review is still open.” Clearing a false positive means closing the thread with a short reason. A later commit that fixes the issue clears the finding automatically. Anthropic points readers to its open-source security review GitHub Action, which is MIT-licensed, and the /security-review command.
4. Automated checks that block
The conventional layer: lint, type checks, tests on every platform and a build. “A typical CLI pull request may run dozens of checks before anyone looks at it.” The PR template asks how the change was tested and how to undo it. Claude can fill that in, “but the person who asked for the change signs off on it.”
5. Human approval, scaled by risk
| Risk tier | Examples Anthropic gives | Human approvals |
|---|---|---|
| Low | Docs, copy, internal-only features, additive changes behind a flag | None, once automated review and security checks are green |
| Medium | Ordinary product changes; sensitive areas such as caching, the auto-updater or system prompts | One person |
| High | The highest-risk code, plus a small set of paths that always need two people | Two people |
Source: Anthropic, “How the Claude Code team does code review”, 15 October 2026.
Five rules sit around the table, and they are the safeguards that make the low tier defensible:
- “The change sets the tier, not the author.” A classifier reads the change and picks the tier. A second classifier asks whether this particular change needs another person even when its tier says no. Some paths always need a person: anything owners list as sensitive, and any CI workflow file.
- “Only trusted authors get the lighter paths.” The repository keeps a trusted list, mostly the owning team. Everyone else needs a second person.
- “An agent’s approval never counts as a person’s.” Automated review can clear a low-risk change, “but it can’t fill a slot that calls for a human.”
- “Whoever prompted the change is on the hook for it.” On an agent-written PR, the person directing the agent counts as one of the required reviewers.
- “An approval covers one specific commit.” If commits land that the system “can’t vouch for, like an agent’s push or a merge someone resolved by hand”, approval has to be given again.
The last rule closes the most obvious hole in any agent workflow: a human approves, then an agent pushes a further change before merge.
6 and 7. Merge, release and rollback
The merge queue re-runs every check against main with the change applied, “so two PRs that pass separately can’t combine into a broken main.” New behaviour usually ships behind a flag to Anthropic employees first, and public releases go to the latest channel before stable. When something still gets through, flags turn off without a deploy, Claude Code has a weekly on-call rotation, and incident reviews ask “which layer should have caught the issue.”
The post is candid about what is missing here. Noticing a bad merge still depends on the author, on-call and dashboards, and “we don’t yet have circuit breakers that tighten approval when those numbers move; engineers here want them before more code moves to zero-human merges.”
How the reviewer itself is evaluated
Anthropic treats the reviewer as a system to be measured, with three mechanisms.
Incidents become the eval set. The team collected past PRs that caused incidents, with their reverts and fix-forwards, and had engineers who know that code confirm each bug and where it lived. “The reviewer runs against that set daily.” Every change to the reviewer’s prompts, tools or model is scored against it, and the set grows with each incident.
Noise is measured by what people do. Catching more bugs is easy if you flag more non-bugs, so every reviewer comment is sorted by the response: fixed, said to be wrong, said to be intentional, or judged not to matter. The team also runs the reviewer on PRs known to be clean and counts how often it reports something “that would have led someone to make a harmful change.” Its written priority is “catching real bugs first and cutting review rounds second.”
Review has to converge. This was the problem the team created for itself. “An agent author and an agent reviewer can keep each other busy indefinitely. One CLI PR went through more than fifty rounds of review and fixes overnight before its author stopped it.” Running git blame on what the reviewer kept flagging, “about 59% of it was code that had been there since the reviewer’s first pass”: the reviewer was finding a few more old bugs each round, not new ones. The post notes why this is worse with agent authors: a person waves off a nit in seconds, an agent fixes it, which means another commit and another review.
The fixes were four rules: a cap of three rounds, after which the reviewer asks the author to reconsider the approach; diff-only re-review after the first few passes; flagging the class of bug so the author fixes every instance; and no repeats of findings already posted. Review agents also run nightly over existing code to catch old bugs before they surface elsewhere.
The numbers Anthropic reports
| Measure | Before | After | Period or context |
|---|---|---|---|
| Merged PRs to Claude Code’s codebase | Baseline | “More than doubled” | June to September 2026 |
| Share of merged PRs reverted | Baseline | Fell “by more than 40 percent” | June to September 2026 |
| Internal PRs passing after one review and fix round | 65% | 78% | Before and after convergence changes |
| Internal PRs needing five or more rounds | 8.9% | 1.5% | Before and after convergence changes |
| Mean reviews to pass | 2.08 | 1.32 | Before and after convergence changes |
| Internal PRs getting substantive review comments | 16% | 54% | Before and after Code Review, per the March 2026 launch post |
All figures are Anthropic-reported. The convergence values are read from the labels of the post’s Figure D. GenAI Brief has not seen the underlying data.
The March 2026 research preview announcement adds internal figures from months of use: on PRs over 1,000 lines changed, 84 per cent got findings, averaging 7.5 issues; on PRs under 50 lines, 31 per cent did, averaging 0.5; and “less than 1% of findings are marked incorrect” by engineers. Anthropic’s security lifecycle post of July 2026 says the company determined that “approximately a third of the bugs behind past claude.ai incidents would have been caught” by its current automated processes.
How much weight the numbers bear
The figures are useful and limited, for reasons the posts themselves make visible:
- No absolute counts. “More than doubled” and “fell by more than 40 percent” describe change without scale. A revert share falling from 5 per cent to 2.5 per cent and one falling from 0.5 to 0.25 per cent are both “more than 40 percent”.
- No control. The post compares June with September and does not separate the review changes from anything else that changed over those months, such as the models and tooling the agents use. In GenAI Brief’s view, the review process is likely one of several changes in the period.
- Before and after what, exactly. The convergence figures are labelled only “before” and “after the convergence work”, without dates or PR counts.
- The eval is Anthropic’s own incidents. That makes it relevant to Anthropic’s code, and a strong design for any team to copy, but it is not an independent benchmark of the reviewer.
- The author is also the vendor. The post doubles as guidance for adopting Anthropic’s paid Code Review service.
The direction of the evidence is consistent across three posts written months apart, and the convergence result in particular has a clear mechanism behind it. What the evidence does not show is how the process would perform on a codebase without Anthropic’s flags, staged releases and heavy internal use, which carry much of the load in layers 6 and 7.
What humans still own
The post lists five responsibilities that stay with people:
- Deciding whether to build it: direction, taste and scope. One team that called its review bottleneck solved still kept human review for changes from outside the team, “so someone asks ‘should we even do this?’”
- Reviewing risky code such as billing, the auto-updater and CI workflows.
- Reviewing architecture that sets a pattern others will copy.
- Reading the evidence: test output, the command that ran and its result, screenshots, the reviewer’s findings. “If you can’t say what the checks would miss, ask for a real review rather than a quick approval.”
- Owning the outcome. “A person is accountable for every change that ships, whoever typed it.”
The second job of code review, spreading knowledge of the codebase, is handled informally. “Nobody on the team keeps a complete mental model of Claude Code in their head, and we don’t think anyone needs to.” When someone needs to understand a part of it, they ask Claude for an explainer of that slice, which “takes minutes and reflects the code as it is today.” The team’s argument is that an explainer for the module you are about to change teaches more than reading a one-line copy change. The norm that holds it together is “you land it, you own it”: small changes, everything reversible, review effort set by blast radius, and incident reviews that look at the system rather than the person.
What the public product does, and does not, do
Anthropic’s post says the public version, Code Review for Claude Code, is generally available on Team and Enterprise plans; it went GA on 15 October 2026, the same day as the post. The documentation describes the same core pipeline: several agents examine the diff and surrounding code in parallel, a verification step filters false positives, findings are deduplicated and ranked, and results are posted as inline comments with a summary and a check run named Claude Code Review.
The differences from the internal process matter for anyone trying to copy it:
| Anthropic’s internal process | Code Review product, per its documentation | |
|---|---|---|
| Can findings block a merge? | Yes, through Anthropic’s own merge rules | “A review never approves or blocks the pull request”; the check run “doesn’t conclude as a failure” |
| Security review | Separate blocking pass | Reviews look for security vulnerabilities among other issues; a separate blocking pass is not described, and /security-review and the GitHub Action are separate tools |
| Risk tiers and human approvals | Classifier-set tiers, trusted authors, per-commit approvals | Not provided; a branch protection and CODEOWNERS job |
| Runs code? | Verification layer runs tests and builds | Reviews read the diff and code “without building or running your code” |
| Where it runs | Not detailed in the post | Anthropic infrastructure; read-only repository access through the Claude GitHub App |
| Review depth | Quick, Standard or Deep per repository | Same three levels; Standard is the default |
| Instructions | CLAUDE.md and REVIEW.md | Same; REVIEW.md is read from the base or default branch, “never from the pull request’s own changes” |
Sources: Anthropic’s 15 October post; Code Review documentation, read 18 November 2026.
That last row is a quiet safeguard in the product: a contributor cannot weaken the reviewer’s instructions in the same PR the reviewer is checking. The documentation also says Code Review is not available to organisations with Zero Data Retention or the HIPAA configuration, is not covered by Anthropic’s Business Associate Agreement, and is not yet available with customer-managed encryption keys. It runs on GitHub, including GitHub Enterprise Server.
The local /code-review command, available on any plan, runs a lighter review in a Claude Code session as a background subagent, with --fix to apply findings and --comment to post them on a PR. It reads CLAUDE.md but not REVIEW.md, so the docs advise putting guidance that should apply in both places in CLAUDE.md.
What it costs
The costs page says Code Review “has no flat per-review price” and is billed on token usage through usage credits, separately from plan usage. Cost scales with review level, change size, the complexity of surrounding code and how many candidate issues need verification. New repositories start at After every push, which “runs the most reviews”. At the research preview launch, Anthropic said reviews “generally average $15–25”. The GA announcement says most reviews now finish in six to ten minutes, about three times faster than the preview’s roughly 20, but gives no new price. It also says eligible Enterprise organisations can claim at least $10,000 in review credits by 15 January 2027.
A hypothetical illustration, using the preview-era average because no later figure is published: a team opening 400 PRs a month at $20 a review spends about $8,000 a month with reviews once per PR. On After every push, with three pushes per PR, the same team would spend about $24,000. The documentation’s advice is to pilot on a few repositories in Once after PR creation or manual mode, read the per-repository average cost in admin settings, and set a monthly spend limit, after which reviews are skipped with a comment explaining why.
How a team could adopt this
Anthropic closes with a checklist. Condensed, and arranged by when each piece applies:
Before the pull request. Give the agent checks it can run, listed in a short CLAUDE.md, with hooks for formatters and linters. Run /code-review and /security-review locally, or a fresh-context subagent review. Add a REVIEW.md and move repeated review comments into it.
On every pull request. Require CI. Add “Testing”, “Risk” and “How to revert” to the PR template. Start an AI reviewer on one repository, tune REVIEW.md for a few weeks, then widen. Add automated security review and “require every review thread resolved before merge”. Match review depth to risk, and cap review rounds.
At approval. Write down risk tiers set from the change, “start strict and loosen with evidence.” Keep lighter paths for trusted authors. Use CODEOWNERS and branch protection so auth, billing, CI and release workflows and installers always need a person. “Never let a bot’s approval replace a required human’s; dismiss approvals on new commits.”
After merge. Merge queue, feature flags, internal use first, staged releases, one-step rollback. Turn incidents and reverts into an eval set and rescore the reviewer whenever its prompts, tools or model change. Measure human time, with revert and incident rates as the guardrail.
Two cautions from the evidence. First, the zero-human tier depends on layers most teams lack: feature flags on new behaviour, heavy internal use before release and a staged channel. A team without them should treat “low risk” more narrowly. Second, the convergence lesson applies to anyone pairing an agent author with an agent reviewer. Without a round cap, the two will generate work for each other, and each round costs tokens. OpenAI’s approach to a similar problem, letting a model approve agent actions inside a sandbox, is covered in our report on its Agents API auto-review.
Anthropic’s own summary of where this goes is measured. Code Review’s March announcement said that approving pull requests was “still a human call”; Anthropic’s repositories now let owners decide which low-risk changes merge on automated checks alone, “and that line keeps moving.” The post ends by asking teams that let agents open pull requests which checks they have automated and “what you think we have wrong”. On the evidence published so far, the strongest parts of the process are the least glamorous: an eval built from real incidents, approvals that expire with each commit, and a three-round cap.
Sources
- How the Claude Code team does code review Anthropic (claude.dev)
- Anthropic Outlines its AI-Powered Code Review Process for Claude Code InfoQ
- Code Review documentation Claude Code documentation
- Customize Code Review Claude Code documentation
- Read and request reviews on a pull request Claude Code documentation
- Code Review costs and usage Claude Code documentation
- Review locally with /code-review Claude Code documentation
- Bringing Code Review to Claude Code Anthropic
- Code Review is now generally available Anthropic
- Automated security reviews in Claude Code Anthropic Help Center
- claude-code-security-review GitHub Action Anthropic on GitHub
- How Anthropic secures its AI-native software development lifecycle Anthropic
- Redesigning source control at Anthropic Anthropic
- Claude Code best practices Claude Code documentation
Frequently asked questions
Does Anthropic still have humans review code written by Claude?
Yes, scaled by risk. Anthropic says low-risk changes such as docs or flagged additive features need no human approval once automated review and security checks pass, ordinary and sensitive changes need one person, and the highest-risk code needs two. The person who directed the agent counts as one of the required reviewers, and an agent's approval never counts as a person's.
What results does Anthropic report for its code review process?
Merged pull requests to the Claude Code codebase more than doubled from June to September 2026 while the share reverted fell by more than 40 per cent. After changes to make reviews converge, PRs passing after one review round rose from 65 to 78 per cent, and mean reviews to pass fell from 2.08 to 1.32. These are Anthropic's own internal figures.
Can Claude Code Review block a pull request from merging?
Not by itself. Anthropic's documentation says a review never approves or blocks the pull request, and its check run doesn't conclude as a failure. Anthropic's own repositories block merges while findings are open through their merge rules, which a team would reproduce with branch protection that requires resolved conversations.
How much does Claude Code Review cost?
There is no flat price. Reviews are billed on token usage through usage credits, separately from plan usage, and scale with review level, change size and how often reviews run. When the research preview launched in March 2026, Anthropic said reviews generally averaged $15 to $25. Admins can set a monthly spend limit.
What is REVIEW.md in Claude Code?
A Markdown file at the repository root, optionally with extra subdirectory files on a protected branch, that tells Code Review what to flag, at what severity and what to skip. Code Review reads it from the base or default branch, never from the pull request's own changes. The local /code-review command reads CLAUDE.md but not REVIEW.md.
How does Anthropic stop AI reviewers and AI authors looping forever?
It caps review at three rounds, after which the reviewer asks the author to reconsider the approach. After the first few passes it re-reviews only the new diff, flags the class of bug so every instance is fixed, and does not repeat findings already posted. Anthropic says one PR went through more than fifty rounds overnight before these changes.


