Risk-Tiered Review: How Anthropic Governs 30,000 Changes a Day

Claude writes roughly 90 percent of Claude Code’s own code. Anthropic’s monorepo went from 2,500 changes per day in May to more than 30,000 in September. Merged pull requests to the Claude Code codebase more than doubled from June to September.

Those numbers are the backdrop for a question every engineering organization running agents will face: when the volume of code outpaces human reading capacity, what replaces line-by-line review?

Anthropic published its answer on October 15. The essay, written by Addy Osmani, Morgan Westlee Lunt, and Qing Wang, describes a system built around a single operating principle: optimize for the minimum amount of human review time that does not raise reverts or incidents.

The Shift: From Gate to Continuous Check

Traditional code review is a gate at the end. Write the code, open a pull request, wait for a colleague. At 30,000 changes per day, the gate breaks. The queue grows. Reviewers skim. Quality drops precisely when volume demands it most.

Anthropic reframed the question. Instead of “did a human read this code?” the team asks: “what could go wrong with this change, and which check (automated or human) is the right one to catch it?”

Review now runs continuously. Most changes pass through automated checks, a Claude review, and a security review before a human is asked to look. The AI reviewer reads the diff against the full repo and the PR’s stated intent. Findings get verified by separate agents before surfacing to humans. Each finding is tagged Important, Nit, or Pre-existing so that a bug the PR did not introduce does not look like the author’s fault.

The share of internal PRs receiving substantive review comments went from 16% to 54% after the AI reviewer launched.

Three Risk Tiers, Not One Process

The core governance design is a risk classifier that assigns each change to one of three tiers:

Low risk (docs, copy, internal features, additive changes behind a flag): zero human approvals required once automated review and security checks pass.

Medium risk (ordinary product changes, caching, auto-updater, system prompts): one human.

High risk (the most sensitive code, plus paths that always require two people): two humans.

The change sets the tier, not the author. A classifier reads the diff and picks the risk level. A second classifier asks whether a particular change needs a person even when its tier says it does not. Some paths always require a human: anything code owners have listed as sensitive, and any CI workflow file.

One rule is absolute: an agent’s approval never counts as a human’s. Automated review can clear a low-risk change, but it cannot fill a slot that calls for a person.

Convergence: Stopping the Infinite Loop

Agent authors and agent reviewers can keep each other busy indefinitely. 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% of it was code that had been there since the reviewer’s first pass. The reviewer was not finding new bugs. It was finding more old ones each round.

The fix was structural:

A round cap. After three rounds, the reviewer asks the author to reconsider the approach.
Diff-only re-review after the initial passes.
Flag the class of bug so the author fixes every instance, not one line.
No repeats of findings already posted.

The results: 65% of PRs passed after one review round before the changes. After: 78%.

Incidents as Evals

The team collected past PRs that caused incidents, along with their fix-forwards and reverts. Engineers who know each area of the code confirmed 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 every case. Score went up? Keep it. Score went down? Drop it.

This closes the loop between production failures and review quality. The eval set grows with every incident, and every reviewer change is measured against all of them.

”You Land It, You Own It”

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, the same as if they had typed the code themselves. An approval covers one specific commit. If new commits land that the system cannot vouch for (an agent’s push, a merge someone resolved by hand), the approval resets.

This is the accountability boundary that makes risk tiers viable. Without clear ownership, lighter review paths become a liability. With it, each tier carries a name.

Several supporting practices keep the ownership model from collapsing. Changes are small and easy to revert. Feature flags turn off without a deploy. Staged releases send new behavior to Anthropic employees first, then to the latest channel, then to stable. Blast radius sets the review bar. Regressions surface fast through telemetry and internal use.

What This Means for Other Teams

Anthropic’s system is built for Anthropic’s scale. Most teams do not have 30,000 changes per day. The transferable parts are the principles, not the infrastructure:

Risk classification replaces uniform review. Not every change carries the same consequence. Treating them equally wastes human attention on low-risk diffs and under-invests in high-risk ones.

Agent approval is structurally separate from human approval. An AI reviewer can flag, filter, and prioritize. It cannot bear accountability. The slots are different.

Incidents feed the reviewer. Review quality is measured against real production failures, not synthetic benchmarks. The eval set grows with every incident.

Convergence is an explicit design goal. Left alone, automated review loops run forever. Round caps, diff-only re-review, and no-repeat rules are not optimizations. They are governance.

We wrote about the governance gap in AI-assisted code review and about intent layers as invisible governance. Anthropic’s system is the first published implementation that fills those gaps at scale, with measured results.

This analysis synthesizes Solving Code Review at Anthropic (Addy Osmani, Morgan Westlee Lunt, Qing Wang, October 2026).

Victorino Group helps teams build risk-tiered review for agent-written code. Let’s talk.