Anthropic Claude Code Review Replaces Routine Human Reading as AI Writes 90% of the Code

Anthropic Claude Code review has entered unfamiliar territory because Claude now writes about 90% of the product’s code, according to the company. From June through September 2026, merged pull requests more than doubled. Yet the share requiring a revert reportedly fell by over 40%.

That pairing creates the real story. Anthropic did not answer an explosion of machine-written code by assigning humans more lines to inspect. It moved most routine reading to other Claude agents, then reserved human approval for changes with greater risk.

This is not simply a faster version of conventional review. It changes what review means, who performs it, and where accountability begins. Anthropic now treats human attention as a scarce resource that should follow risk rather than every individual line.

The approach also arrives with an important limitation. The headline results are Anthropic’s own measurements, without published raw data or independent auditing. Its process depends on extensive automation, internal infrastructure, staged releases, and unusually heavy access to its own models.

The resulting contest is not Claude against human programmers. It is automated coverage against universal human inspection. Anthropic is betting that layered checks, targeted approvals, and cheap reversibility can control more risk than line-by-line reading at machine speed.

What Changed in Anthropic Claude Code Review

Anthropic moved code review from one human gate into a continuous system of automated checks, agent reviewers, targeted approvals, and rapid rollback.

The company described the system in an October 15 engineering post about Claude Code review. Authors Addy Osmani, Morgan Westlee Lunt, and Qing Wang framed the problem around output volume. When agents generate changes faster than people can read them, a traditional queue becomes a delivery bottleneck.

Anthropic says every pull request receives a Claude review before a person examines it. The reviewer reads the proposed change against the wider repository and the pull request’s stated intent. For bug fixes, it attempts to identify the root cause rather than checking only the visible patch.

Several agents then search for potential defects in parallel. Another group votes on each finding, and the system posts an issue only when enough reviewers agree. Anthropic says it tested filters that remove comments limited to style, diagnostics, or optional cleanup.

The remaining findings receive severity labels. Developers or agents must either fix each finding or close its thread with a reason. A separate automated security review can also prevent a merge while an issue remains unresolved.

These reviews sit beside conventional safeguards. Pull requests still face linting, type checks, builds, and tests across supported platforms. A merge queue reruns checks against the current main branch, reducing failures caused by independently valid changes interacting badly.

Review starts before a pull request exists. Claude runs tests, builds, or visual checks and displays the resulting evidence. A subagent with fresh context then inspects the diff, which reduces the chance that the authoring agent simply repeats its original assumptions.

Anthropic’s earlier coding practices recommended separating authoring and verification contexts. The new workflow turns that recommendation into an operating system for the entire team.

Human approval depends on the change’s classified risk. Low-risk work can merge after automated and security checks pass. Examples include documentation, copy changes, internal features, and additions hidden behind feature flags.

Ordinary product work generally requires one person. Sensitive areas such as caching, system prompts, and update mechanisms also receive human attention. The highest-risk changes require two people, while certain protected paths always trigger manual review.

The classifier evaluates the change, not whether a person or agent wrote it. A second classifier can still demand human involvement when the original tier appears too permissive. An agent’s approval never fills a slot reserved for a person.

This distinction matters. Anthropic has not eliminated human accountability or claimed that AI review makes software error-free. It has separated routine defect detection from decisions involving architecture, product direction, sensitive systems, and acceptable risk.

The person who instructed Claude remains responsible for the result. Each approval applies to a specific commit, so later changes can invalidate it. In Anthropic’s model, delegation changes who types and reads the code, but not who owns the outcome.

The Numbers Make Human-Only Review Unsustainable

Anthropic’s reported metrics suggest that code production has already outrun any review process built around universal human reading.

The company says merged pull requests in the Claude Code repository more than doubled between June and September 2026. During the same period, the share needing reverts fell by more than 40%.

Those figures describe direction, not complete performance. Anthropic did not disclose the absolute pull request count, original revert rate, final revert rate, or statistical variation. A 40% relative decline could begin from either a high or low baseline.

The 90% figure also needs careful wording. Anthropic says Claude writes about 90% of Claude Code’s code. That does not mean the model independently chooses product priorities, defines every requirement, or bears responsibility for deployment.

The engineers still direct tasks, judge evidence, resolve design tradeoffs, and decide whether work should exist. Machine authorship measures code generation, while software engineering includes far more than producing lines.

Even with those qualifications, Anthropic faces a real scaling problem. Its separate monorepo reportedly grew from about 2,500 merged changes per day in May to over 30,000 in September. The company built an internal source-control system named Scion to handle that workload.

Claude Code uses a separate repository, so the 30,000-change figure does not measure the product team directly. Still, Anthropic’s account of its source-control redesign shows the broader pressure surrounding its development infrastructure.

The Scion and Claude Code stories point to the same bottleneck. Once coding agents can create, test, and revise changes continuously, writing code stops controlling throughput. Review queues, builds, permissions, integration systems, and release controls become the limiting factors.

Traditional code review assumes that a manageable number of changes arrive from people. Another person reads each diff, requests revisions, and approves the final version. That model begins to break when output rises faster than reviewer capacity.

Adding reviewers does not fully solve the mismatch. Experienced engineers are scarce, and constant review interrupts design work, debugging, and product decisions. An organization can increase review staffing while still losing shared attention across a growing change stream.

Anthropic therefore measures more than the number of comments produced. It tracks human approvals per pull request, human comments, waiting time, reverts, and incidents. The stated goal is reducing human review time without shifting that time into production recovery.

The company also reports that its commercial AI reviewer increased the share of internal pull requests receiving substantive comments from 16% to 54%. Most changes above 1,000 lines reportedly attract findings, while most smaller changes return clean.

That result does not establish accuracy by itself. More comments can represent better detection, more noise, or both. Anthropic says it evaluates comment quality by observing whether developers fix findings, reject them, or identify the reported behavior as intentional.

The larger signal is organizational. Anthropic no longer treats a human reading every changed line as the defining proof of review. It measures whether the combined system catches problems, directs attention well, and limits production damage.

That change pressures every engineering organization deploying coding agents. If agent output grows while review policy stays fixed, queues expand and expected productivity gains disappear. Teams must either restrict generation or redesign how they validate it.

Automated Coverage Is Challenging Universal Human Inspection

The central contest is between broad machine coverage and the belief that every meaningful change deserves direct human reading.

Universal human inspection offers an intuitive promise. A qualified engineer understands the code, sees the change, and accepts responsibility before it ships. That practice can spread knowledge while catching assumptions that automated tests miss.

However, the promise weakens when review becomes rushed. A person facing a large queue can scan rather than reason, approve familiar-looking code, or focus on style instead of behavior. A human signature does not guarantee comprehension.

Anthropic’s alternative uses multiple specialized layers. One agent authors the change, another reviews with fresh context, several agents search for bugs, and separate agents assess each finding. Security review, continuous integration, merge checks, staged release, and rollback cover different failure modes.

This resembles defense in depth. No individual layer needs perfect recall because later layers can catch what earlier ones miss. Risk classification then directs scarce human judgment toward changes with greater potential impact.

The mechanism also gives Anthropic wider review coverage. Machines can inspect every pull request without waiting for a colleague’s schedule. They can examine repository context, apply documented conventions, and repeat the same checks across thousands of changes.

Instructions stored in CLAUDE.md describe the project, its conventions, and its boundaries. A separate REVIEW.md tells the reviewer what failure looks like in a particular repository. Code owners can identify sensitive paths and exclude irrelevant ones.

When the reviewer repeatedly flags a mistake, the team can move the lesson upstream. It can add a lint rule, improve an instruction file, modify a skill, or create a new automated check. Review feedback then becomes reusable infrastructure.

Past failures become evaluation cases. Anthropic says it collected pull requests associated with incidents, reverts, and later fixes. Engineers verified the underlying bugs, and the reviewer now runs against that set every day.

This is a significant departure from review as a meeting between two people. The system attempts to preserve lessons in executable checks rather than depending on individual memory. Each incident can expand the organization’s future detection coverage.

Yet human review still handles questions that cannot be reduced to local correctness. Engineers decide whether a feature should exist, whether an abstraction sets a harmful precedent, and whether evidence supports deployment.

They also inspect sensitive areas, including billing, update mechanisms, continuous integration, and release workflows. These changes can have a wide blast radius even when their code appears locally correct.

The process therefore does not declare machines better reviewers in every dimension. It assigns machines the reading work they can perform repeatedly, while assigning people decisions involving purpose, architecture, uncertainty, and responsibility.

That division also changes engineering skill. Engineers need to specify intent, identify constraints, design verification, interpret evidence, and recognize when an agent optimized the wrong objective. Reading code remains useful, but it is no longer the only path to understanding.

Anthropic’s Scion team offered a related example. Engineers reported that Claude sometimes pursued inefficient or overly defensive designs that fit local patterns. Humans had to reject those directions because they understood system-level tradeoffs.

The phrase “human in the loop” can obscure this role. A person who merely approves machine output is a weak safeguard. A person who defines boundaries, chooses evidence, and knows when to stop the automation provides meaningful control.

For other organizations, the lesson is not to remove reviewers. It is to distinguish mechanical inspection from judgment. Automated coverage becomes valuable when people retain authority over high-consequence decisions and unclear evidence.

How Claude Code Reviews Avoid Endless Agent Loops

Anthropic discovered that AI authors and AI reviewers can create unlimited work unless the review process is explicitly designed to converge.

More review is not automatically better. Anthropic describes one Claude Code pull request that went through more than 50 review-and-fix rounds overnight. The author eventually stopped the loop.

The reviewer was not discovering a fresh critical defect during every pass. Anthropic used version history to inspect the repeated findings and found that about 59% concerned code present during the first review.

The agent kept locating additional old issues rather than evaluating only the new correction. Each comment triggered another fix, commit, and review. The system remained active without moving efficiently toward an acceptable final state.

This failure illustrates a distinctive AI code review risk. A person can dismiss a low-value suggestion within seconds. An authoring agent tends to act on it, producing another diff that gives the reviewing agent more material.

Anthropic responded with convergence controls. After three rounds, the reviewer asks the author to reconsider the approach. Later passes focus on the new diff instead of repeatedly searching the full change.

The reviewer also reports an entire class of related defects at once. That lets the author fix every instance instead of receiving similar comments across consecutive rounds. Previously posted findings should not appear again.

Anthropic says these changes improved its internal review cycle. The share of pull requests passing after one review-and-fix round reportedly rose from 65% to 78%.

Pull requests needing five or more rounds reportedly fell from 8.9% to 1.5%. Mean reviews before passing declined from 2.08 to 1.32. These metrics remain company-reported, but they address an operational problem that many agent workflows overlook.

Convergence matters because automated labor is not free simply because it lacks a salary. Every additional round consumes model capacity, delays the change, creates more code, and increases the material that later checks must inspect.

The same problem appears when reviewers overreact to hypothetical threats. Anthropic says adversarial review can become myopic, encouraging excessive validation or complexity. A system optimized to discover possible failures can create new maintenance costs.

Risk-based depth offers one control. Anthropic’s generally available Code Review service supports different review levels for routine and critical repositories. The company says most reviews now finish in six to ten minutes.

However, a faster reviewer does not resolve the underlying governance question. Teams still need to decide which findings matter, which paths deserve deeper inspection, and how many cycles are acceptable.

Review instructions can also become a hidden policy layer. If CLAUDE.md, REVIEW.md, or classification prompts contain weak assumptions, agents can apply those assumptions consistently across the repository.

Consistency helps only when the rule is correct. Teams need ownership, version control, evaluation cases, and review for the instructions guiding their reviewers. Otherwise, automation can scale a mistaken policy faster than humans notice.

This is where shared engineering context becomes important. Organizations adopting agents need durable records of architecture decisions, incident lessons, and rejected approaches. A searchable engineering knowledge base can help preserve that context beyond one review thread.

Anthropic’s process works because it treats the reviewer as a system that needs measurement. It tracks accuracy, noise, rounds, incidents, and developer responses. Installing an AI reviewer without those feedback loops would copy the visible tool but miss the operating model.

What Anthropic’s Results Do Not Yet Prove

The strongest claims remain self-reported, and Anthropic has not shown that its results transfer to teams with different infrastructure, budgets, or failure tolerance.

The first uncertainty concerns measurement. Anthropic reported that merged pull requests more than doubled and the revert share fell by over 40%. It did not release the underlying dataset, absolute rates, or incident severity distribution.

A falling revert share can be encouraging while still hiding important outcomes. Teams can fix forward rather than revert, disable a feature flag, or tolerate a regression that never receives that label. Reverts are useful, but incomplete.

Incident rates provide another guardrail, yet the public post does not provide a detailed incident series. Without severity and exposure data, outsiders cannot determine whether the process reduced risk or changed how failures were handled.

The 90% authorship number carries similar ambiguity. It does not specify whether the measurement counts generated lines, accepted lines, commits, or another unit. It also does not reveal how much human prompting, editing, and iteration preceded the final code.

Anthropic’s environment is unusually favorable to this method. The company controls the models, can spend substantial compute on parallel reviewers, and develops internal infrastructure around agent-generated workloads.

Its employees also dogfood Claude Code before public releases. New features can move through internal deployment, a latest channel, and then a stable channel. Feature flags let the team disable behavior without a complete deployment.

Teams operating medical, financial, industrial, or safety-critical systems may face different requirements. A quick rollback cannot undo every consequence. A flawed data migration, authorization change, or external action can produce irreversible harm.

Anthropic acknowledges that bad merges still depend on authors, on-call engineers, telemetry, and dashboards for detection. It does not yet have automatic circuit breakers that increase approval requirements when reverts or incidents rise.

That gap matters because risk classification can become stale. A change labeled low risk may interact with hidden dependencies. A series of individually safe changes can also produce a dangerous combined state.

Security introduces another concern. Anthropic uses automated security review, but its own risk materials show why human oversight remains necessary. Its sabotage assessment describes model monitoring as an evolving control rather than a complete guarantee.

Community reaction has raised broader questions about cost and understanding. Some developers argue that Anthropic can sustain review patterns that would be uneconomical elsewhere. Others worry that fewer people reading diffs will weaken collective knowledge of the codebase.

Anthropic openly states that nobody on the Claude Code team maintains a complete mental model of the product. Engineers instead ask Claude to explain the relevant subsystem when they need it.

That approach can keep explanations current, but it creates a dependency. If the generated explanation misses an interaction, the engineer may make a decision using an incomplete map. The same model family may also repeat assumptions embedded in the code it reviews.

Cross-model review could provide additional diversity, but it does not automatically improve accuracy. Different systems can share training patterns or fail for unrelated reasons. The important property is independent evidence, not merely a different model name.

None of these questions invalidates Anthropic’s reported results. They limit what those results establish. The company has shown a detailed internal process with encouraging directional metrics, not a universal replacement for human code review.

Three Signals Will Test Whether the Model Holds

The next test is whether Anthropic can preserve quality as zero-human merges expand, review products reach other companies, and competitors adopt different controls.

The first signal is Anthropic’s own approval policy. Its current process permits selected low-risk changes to merge without a separate human reviewer after automated checks pass.

Watch whether that boundary expands into more product code. If Anthropic adds the circuit breakers its engineers want, automatic escalation could make wider deployment more credible. Rising incidents or a return to stricter approvals would weaken the case.

The second signal is evidence from external organizations using automated review. Anthropic has released Code Review for Team and Enterprise customers, creating a wider test across unfamiliar repositories and engineering cultures.

The useful metrics will not be the number of comments or reviewed pull requests. Teams should report accepted findings, escaped defects, false positives, review latency, human effort, and production incidents.

Comparable results outside Anthropic would strengthen the claim that layered AI review can scale. High noise, escalating model usage, or unchanged incident rates would suggest that Anthropic’s success depends on its internal environment.

The third signal is the competitive response. OpenAI, GitHub, Google, Cursor, and other coding-agent providers face the same imbalance between generated code and reviewer capacity.

Their choices will reveal whether risk-based review becomes a shared pattern. Competing systems may favor cross-model review, stronger sandboxing, formal verification, repository-specific evaluation, or more persistent human approval.

Developers should resist reducing this debate to whether AI can find bugs. The practical question is whether a complete review system can allocate attention, preserve accountability, and recover safely when every layer misses something.

For engineering leaders, the immediate action is measurement. Establish baseline review time, escaped defects, false positives, revert rates, and incident severity before changing approval policy. Without that baseline, faster merging can look like improvement while moving costs elsewhere.

Teams should also separate reversible changes from irreversible ones. Documentation, flagged interface adjustments, and internal tools do not deserve the same process as authentication, billing, migrations, or release infrastructure.

Anthropic Claude Code review offers a concrete answer to a problem many teams will soon face. It treats review as a layered control system rather than proof that a person read every line.

The company’s reported numbers make that answer worth testing, not blindly copying. If your agents double code output tomorrow, which evidence would let your reviewers safely stop reading everything today?