Claude writes and reviews close to 90% of the code for Claude Code, according to the team developing the tool at Anthropic. The figure does not describe an unsupervised process: the team has shifted much of the review to agents and automated checks, while reserving decisions about sensitive changes and responsibility for what reaches production for people.
Anthropic's proposal is specific: instead of asking a person to read every line, the agent should run the change and provide evidence that it works. The team describes a workflow in which Claude runs tests, builds, and behavior checks; another agent reviews the diff, and checks that still fail after several rounds are handed over to people. Review does not disappear: it shifts to a different place and is organized around evidence and risk.
From reading every diff to checking the result
For the team, a useful test does more than confirm that the code compiles. The most convincing verification is to run the application as a person would: operate the web version with browser tools, test a mobile app in a simulator, or start a service to check its changes. In its workflow, Claude must show what it ran and what result it got, rather than simply declaring that it is done.
Anthropic recommends investing in end-to-end tests, which cover complete user actions and provide concrete signals when something fails. It also highlights property-based tests, which generate inputs to test invariants, and differential tests, which compare the old and new system's responses to the same inputs. The latter are especially useful in migrations where behavior is expected to remain the same.
The company says that, in internal tests on structured file generation, adding a separate evaluator that compares the result against a rubric increased task success by up to 10 points compared with a standard instruction cycle. The greatest increase was seen in the most difficult problems. This is a result from that specific context, not a general measure of how much any programming task improves.
If a check is still failing after three rounds, Claude stops and brings in a human.
— Claude Code Team, Anthropic
Anthropic sets a limit: if a check is still failing after three rounds, Claude stops and calls in a person. The team also limits repeated reviews. For one change request, it observed more than fifty overnight rounds of review and fixes; when it analyzed the findings, it found that around 59% concerned code that was already present in the reviewer's first pass.
Automated checks, with a person at the end
Review is divided into layers. Before opening a change request, Claude runs tests, builds, and the linter; then an automated reviewer examines the diff alongside the repository and the stated purpose. In security review and routine checks—such as tests and type checks—outstanding findings can block integration. An integration queue reruns the checks with the change applied to the main branch.
The team does not apply the same human requirement to every change. A classifier assigns a risk level based on the change, and another can request an additional person even if the initial category does not require one. The table summarizes the approach Anthropic describes:
| Risk | Examples | Human approvals |
|---|---|---|
| Low | Documentation, text, internal functions, and additive changes protected by a flag | None, if they pass automated and security review |
| Medium | Routine changes and sensitive areas such as caching, the updater, or system instructions | One person |
| High | Higher-risk code and paths that always require two reviewers | Two people |
There are two explicit limits: an agent's approval does not count as human approval, and the person who commissioned the change counts as one of the required reviewers. Authors who are not on the repository's trusted list also need a second person to access the lighter-weight paths. In this way, automation can clear low-risk changes, but it does not replace a human when policy requires their involvement.
The rules also aim to prevent a change from modifying the test used to judge it. In Claude Code, the reviewer reads the REVIEW.md file from the base branch, not from the change request. The team also maintains a reliability checklist with 39 items, each associated with a signal detectable in the diff and with previous incidents or requests. Claude checks only the items whose triggers match the change.

The cost of automating review
More reviews do not always mean more safety. If a test is flaky, the agent may learn to repeat it instead of fixing the problem; if it takes too long, it may reduce the number of checks per batch. And when an agent author responds to every observation with another modification, even minor comments generate new commits and another review round. Anthropic shortened this cycle with a round limit, diff-focused reviews after the first passes, and a rule against repeating findings that have already been posted.
InfoQ adds a caveat about understanding the system. In its analysis of Anthropic's review process, it reports the view that no one on the team needs to maintain a complete mental model of Claude Code: anyone who wants to understand a part can ask Claude to explain that section. InfoQ also describes a case in the repository where a Claude-generated answer about the automatic closing of issues inaccurately described how they were handled. The example shows that an explanation produced by the agent does not, by itself, guarantee that it has correctly understood the actual behavior.
There is also a governance question: who decides whether a change to the agent's instructions is low or high risk? InfoQ notes that Anthropic does not explicitly assign a category to files such as CLAUDE.md, even though the reviewer loads them during every review. Anthropic's article does say that some sensitive changes, such as those affecting system instructions, require human approval. For a company adopting a similar workflow, how those files are classified can affect which changes reach production with less oversight.
More changes, with rollback as a backstop
The context is a growing volume of code. In another post, the team says that, between May and September, the number of changes incorporated each day into Anthropic's monorepo rose from around 2,500 to more than 30,000. That figure refers to the monorepo, not just Claude Code. In the Claude Code repository, merged requests more than doubled between June and September, while the proportion that had to be reverted fell by more than 40%, according to Anthropic.
The company measures the time people spend reviewing, but also tracks reversions and incidents: reducing manual reading would not help if the cost reappeared in the form of fixing failures. Changes are usually first released behind a flag for employees and then go to the latest channel first, while the stable channel lags behind. If something goes wrong, flags make it possible to disable the feature without deploying a new version.
This approach leaves people with tasks that go beyond approving a diff: deciding whether a feature is worth building, judging the architecture that will set patterns for others, and carefully examining high-risk changes. Anthropic also acknowledges that it still does not have automated switches that raise the approval level when incidents or reversions increase. Its engineers want to have them before moving more changes to integrations without human intervention.
The practical takeaway for other teams is not that they can copy the automation percentage, but that they need to decide what evidence justifies integrating a change and what failures require stopping it. Anthropic turns incidents and reversions into evaluations to improve the reviewer, and requires people to review and approve new rules. The system still depends on a final human decision for higher-risk changes and on the ability to quickly roll back changes that get past the checks.
Sources: claude.dev Blog, claude.dev Blog, InfoQ