2026-10-20

How the Claude Code team reviews agent-written code, and what you can copy

A decode of Anthropic's layered review process (AI review, risk-tiered approvals, fast rollback) for teams whose agents outpace human reviewers.

Picture a four-person product team at a B2B SaaS shop. Two engineers run coding agents most of the day, and a few more PRs arrive overnight from an agent working through tickets. The tech lead still reads every diff before merge, because that's the rule. By mid-morning there are a dozen open PRs, with a docs typo next to a change to the billing webhook, and all of them wait on the same person. The lead either rubber-stamps the small ones to keep up, or the queue grows and the agents' speed goes to waste. Neither approach shows which changes actually needed a human.

The Claude Code team at Anthropic published an account of how it handles this on October 15, 2026, at far higher volume. Anthropic says that from June to September, 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 method is not reading less for its own sake. In the post's words, the team "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." Copy the structure. You don't need their volume to benefit.

What it is

This is a process write-up with one product inside it. Here are the layers, mapped to the lede's problem, as Anthropic describes them:

Review before a PR exists. Claude gets something it can run, such as tests, a build or a screenshot to compare against the design, and has to show the output instead of saying it's done. A subagent then reviews the diff with fresh context. The post quotes Boris Cherny, who created Claude Code, estimating that giving Claude a way to verify its work makes the final result two to three times better. This keeps routine mistakes away from the lead.
Fix repeat findings at the source. When the reviewer keeps flagging the same thing, the team changes a skill, adds a lint rule or updates an instruction file. CLAUDE.md stays short and describes the project. REVIEW.md, written by code owners, says what failure looks like in that part of the code ("it lies" for docs, "it misroutes" for config). It also caps nits, lists paths to skip and asks for a file and line as evidence.
A Claude review on every PR. Several agents hunt for bugs in parallel. A separate group then votes on each finding, and only findings enough of them agree on get posted. Style-only findings are dropped. The rest are tagged Important, Nit or Pre-existing, and every one has to be fixed or resolved with a reason. The public version, Code Review for Claude Code, is generally available on Team and Enterprise plans, and /code-review runs a lighter version locally. Admins set each repo to Quick, Standard or Deep. After the research preview launched, the share of internal PRs getting substantive comments went from 16% to 54%.
Blocking security review. A PR can't merge while any bug or security finding is still open. The post points outside teams to the /security-review command or an open-source GitHub Action.
Risk tiers instead of a blanket rule. Low-risk changes (docs, copy, additive changes behind a flag) need no human once automated checks are green. Medium-risk changes need one person and high-risk changes need two. A classifier reads the change and picks the tier, so the author doesn't. An agent's approval never counts as a person's. The person directing an agent counts as one of the required reviewers, and an approval covers one specific commit.
Cheap undo. A merge queue re-runs checks against main, new behavior ships behind flags to employees first, flags turn off without a deploy, and a weekly on-call rotation watches for problems.

Alternatives the sources cover:

@poteto's "inverse pyramid" (X post): put most effort into codebase design and deterministic checks (types, lint, tests, TLA+), less into prose rules, and the least into human review. The trade-off is upfront work on architecture in exchange for less dependence on an AI reviewer. It is packaged as pstack for Cursor, which also installs in Claude Code, and there is a port for Codex, Copilot and others.
A small-team DIY version (DEV Community): GitHub branch protection, a short REVIEW.md and one CI workflow, which covers five of Anthropic's seven layers. The two it says you can't copy are the risk classifier and staged release channels at Anthropic's volume.

Our sources don't compare other vendors' AI code reviewers, so we won't either.

Who it's for

Pick this up if your agents already open more PRs than your humans can read properly, and you have CI that can block a merge. Claude Code users can apply the most of it directly, because the review commands and the hosted product are Anthropic's.

Skip the AI-review layer if your PRs are tiny and you genuinely read each one. The DEV Community guide sets that line at about 20 lines. If you have no required checks or rollback path, start there instead, because every other layer here assumes those exist. Solo developers can borrow the tiers to decide how careful to be, but there is nobody to route approvals to.

Before and after

Before:

The agent writes code and says it's done.
A PR opens and waits for the lead.
The lead reads every diff at the same depth, whether it's docs or billing.
A bad merge is found by users and fixed with a redeploy.

After, following Anthropic's flow:

The agent runs tests or a build, shows the output, and a fresh-context subagent reviews the diff.
The PR gets an automated bug review and security review. Open findings block the merge.
Required CI runs (lint, types, tests, build).
The risk tier sets zero, one or two human approvals, and sensitive paths always get a person.
The merge queue re-checks against main and new behavior ships behind a flag.
If something slips through, the flag goes off without a deploy, and the incident review asks which layer should have caught it.

The lead's time moves from reading the docs typo to the billing change.

Try it

The smallest steps the sources support:

Make the agent prove its work. The DEV Community guide suggests putting "run the test command and a diff-review subagent before opening a PR" in CLAUDE.md. It estimates 30 minutes.
Write a short REVIEW.md following Anthropic's guidance above: what failure looks like, a cap on nits, paths to skip, file-and-line evidence, and a summary that starts with a count.
Run /code-review and /security-review locally in Claude Code before opening a PR.
Make lint, type checks, tests and build required status checks. The DEV guide says that if you do only three things, do required checks, a risk rule and a rollback you have actually practiced.
On a Team or Enterprise plan, try the hosted Code Review and choose Quick, Standard or Deep per repo. None of our sources give pricing. The DEV guide lists it as "plus usage cost."

To try the inverse-pyramid route, the pstack README gives this Claude Code install:

/plugin marketplace add cursor/plugins
/plugin install pstack@cursor-plugins

Then run /pstack:setup-pstack to pick models, and /pstack:poteto-mode for tasks that need rigor. The README notes that steps needing Cursor-only features are skipped in Claude Code.

Where it breaks

The headline numbers are internal and relative. The post doesn't give the baseline revert rate, and nobody outside Anthropic has checked the figures. Model upgrades over the same June–September window aren't separated from the effect of the review changes. AICoder notes that no raw data was published. The DEV guide says to treat the numbers "as a direction, not a benchmark."
Unconfirmed convergence stats. AICoder and DEV Community report that single-round passes rose from 65% to 78% and that PRs needing five or more rounds fell from 8.9% to 1.5%. We couldn't find these figures in the text of the primary post we fetched, so treat them as unverified.
Review loops. Anthropic says one CLI PR went through more than fifty overnight rounds of review and fixes before its author stopped it. About 59% of what the reviewer kept flagging was code that had been there since its first pass. Noise also costs more when the author is an agent, because the agent fixes every nit and triggers another round.
No circuit breakers yet. Anthropic says it lacks automatic tightening of approvals when revert or incident numbers move. Its engineers want that before more code moves to zero-human merges.
Blocking is your job. According to the DEV guide, Anthropic's docs say the hosted Code Review never approves or blocks a PR by itself, so your CI has to do the blocking. The hosted product is also limited to Team and Enterprise plans, and the risk classifier and trusted-author lists are Anthropic-internal.
Untested on thinner setups. No source covers how this works with low test coverage or without a merge queue and feature flags.
Human attention is still the limit. Anthropic's workforce study calls human attention "the bottleneck for agent output." Fortune reports that 80% of elapsed time in Claude sessions was agents waiting on human input. TechCrunch notes that Anthropic acknowledges "more code does not necessarily mean better code," though it says it hasn't found signs that quality is declining.
Less shared understanding. The post itself says review's second job is spreading understanding of the codebase. Fewer humans reading diffs means less of that, and it's a trade-off to plan for.

Who picks this: teams already drowning in agent PRs who have blocking CI and a working rollback. Who skips it: teams still reading small PRs comfortably, or teams without tests and flags, who should build those first.