# Claude Writes 90% of Claude Code: How Review Keeps Up

> Anthropic says Claude writes about 90% of Claude Code. How its team reviews it: risk-tiered approvals, a three-round cap, and reverts down over 40%.

- Author: Nitish Garg, Founder & CEO, CellCog
- Published: 2026-10-17
- Canonical (HTML): https://cellcog.ai/blog/claude-code-90-percent-code-review/
- Section: Guides / Choosing a platform
- Publisher: CellCog (https://cellcog.ai), the AI employee platform. Blog index for agents: https://cellcog.ai/blog/llms.txt

## Key points

- Anthropic says Claude writes about 90% of Claude Code's own code; from June to September merged pull requests more than doubled while reverts fell by more than 40%.
- Most review now happens before a pull request: Claude runs tests, build and linter, then a second agent reviews the diff in a fresh context.
- Every pull request gets CI, a parallel Claude code review with voted findings, and a separate security review; open findings block the merge.
- A classifier sets human approvals by risk: none for low-risk changes, one person for medium, two for the highest-risk code.
- After one pull request ran 50+ review rounds overnight, a three-round cap lifted first-round passes from 65% to 78%.
- Code Review for Claude Code is generally available on Team and Enterprise plans, with Quick, Standard and Deep settings.

## At a glance

- **Does Claude really write 90% of Claude Code?** Anthropic says Claude writes about 90 percent of Claude Code's own code, in its October 15, 2026 post on code review.
- **Did quality drop?** Anthropic says merged pull requests more than doubled from June to September while the share reverted fell by more than 40 percent.
- **Can I use the same reviewer?** Code Review for Claude Code is generally available on Team and Enterprise plans; /code-review runs a lighter version locally.

**Anthropic says Claude writes about 90% of Claude Code's own code, and on October 15, 2026 its team explained how it reviews that much code without slowing down.** The post on [claude.dev](https://claude.dev/blog/solving-code-review-at-anthropic/), by Addy Osmani, Morgan Westlee Lunt and Qing Wang, opens with the number: "We've said before that Claude writes about 90 percent of Claude Code's own code." The next day, [@ClaudeDevs on X](https://x.com/ClaudeDevs/status/2111168901723906176) put the result in one line.

The result: "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." More code shipped, and less of it had to be pulled back. Here is the review system behind that, layer by layer, and what a team can copy from it today.

## Why line-by-line review stopped working

The volume changed first. Anthropic's post says changes landing per day in its monorepo "went from about 2,500 in May to more than 30,000 in September", the same jump behind its switch to [Scion](https://cellcog.ai/blog/anthropic-scion/). Claude Code lives in its own repository, but the post says "it's seeing a lot of pressure too."

So the team changed the question. Instead of asking whether a human read every line, it asks which check, automated or human, is the right one to catch what could go wrong with a change. Its stated goal is that most pull requests in the Claude Code repos "merge with at most one human in the loop", with no rise in reverts or incidents. Revert and incident rates are the guardrail: if they climb, the post says, human time was only moved, not saved.

## The layers a change passes through

Most review now happens before a pull request exists. Claude runs the tests, the build and the linter, then a second agent reviews the diff in a fresh context. Boris Cherny, who created Claude Code, estimates in the post that giving Claude a way to verify its work makes the result two to three times better.

On every pull request, four more layers run:

1. **Required CI.** Lint, types, tests on every platform, build and packaging. A red check blocks the merge.
2. **Claude code review.** Several agents hunt for bugs in parallel, a separate group votes on each finding, and only findings enough of them agree on get posted, sorted by severity and tagged Important, Nit or Pre-existing. Every finding has to be fixed or closed with a reason.
3. **Security review.** A separate pass. An open finding from either review blocks the merge.
4. **Risk-based human approval.** A classifier sets how many people must approve.

![Animation: change cards drop through six layers, verified first, required CI, AI review, security review, human approval and merge queue; one flawed card is stopped at AI review and another slips through into the fast rollback net, which turns amber and catches it](https://cellcog.ai/blog/media/claude-code-90-percent-code-review/cc90-layers.svg)
*Six layers of checks, with fast rollback under them*

After that comes a merge queue that re-runs every check against the latest main, new behavior behind a flag for Anthropic employees first, a gradual release from the latest channel to stable, and fast rollback when something still gets through.

## Who has to approve what

*Table: Human approvals on Claude Code pull requests, by risk (Anthropic, October 15, 2026)*

| Risk | Examples Anthropic gives | Human approvals |
|---|---|---|
| Low | Docs, copy, internal-only features, additive changes behind a flag | None, once automated and security review are green |
| Medium | Ordinary product changes; caching, the auto-updater, system prompts | One person |
| High | The highest-risk code and a small set of named paths | Two people |

Three rules keep that table honest. The change sets the tier, not the author: a classifier reads the diff, and a second classifier asks whether this change needs a person even when its tier says no. Only authors on a repo's trusted list get the lighter paths. And "An agent's approval never counts as a person's": on an agent-written pull request, the person directing the agent counts as one of the required reviewers.

## The reviewer that would not stop

Agent authors create a problem human authors do not. A person waves off a nit in seconds; an agent fixes it, which means another commit and another review round. The post describes one CLI pull request that "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% was code that had been there since the reviewer's first pass: it was finding a few more old bugs each round, not new ones.

The fix was a set of limits. After three rounds, the reviewer asks the author to step back and rethink the approach. Later passes review only the new diff. The reviewer flags a class of bug so the author fixes every instance, and it never repeats a finding it already posted.

*Table: Internal pull requests before and after the review-convergence changes (Anthropic, October 15, 2026)*

| Metric | Before | After |
|---|---:|---:|
| Pass after one review and fix round | 65% | 78% |
| Need five or more rounds | 8.9% | 1.5% |
| Mean reviews to pass | 2.08 | 1.32 |

![Animation: an agent author and an agent reviewer pass a change card back and forth while a counter steps 1, 2, 3; an amber barrier then stops the card with the label rethink the approach](https://cellcog.ai/blog/media/claude-code-90-percent-code-review/cc90-round-cap.svg)
*After three review rounds, the reviewer stops the loop*

The reviewer itself is graded every day. The team turned past pull requests that caused incidents into an evaluation set, confirmed each bug with engineers who know that code, and scores every change to the reviewer's prompts, tools or model against it. It also measures noise by what people do with each comment: fixed it, called it wrong, called it intended, or ignored it.

## What people still decide

The post lists five jobs that stayed with humans: whether to build something at all, risky code such as billing, the auto-updater and CI workflows, architecture that others will copy, reading the evidence (test output, the command that ran, a screenshot), and owning the outcome. "A person is accountable for every change that ships, whoever typed it."

The team is open about one gap: "We don't yet have circuit breakers that tighten approval when those numbers move", and the post says engineers want them before more code moves to zero-human merges.

## What you can use today

Anthropic says the public version, [Code Review for Claude Code](https://code.claude.com/docs/en/code-review), is now generally available on Team and Enterprise plans, with Quick, Standard and Deep settings per repository, and that /code-review runs a lighter version locally. During the research preview, the share of internal pull requests getting substantive review comments went from 16% to 54%. A /security-review command and an open-source security review GitHub Action cover the second layer. The rest is process: a short CLAUDE.md with checks the agent can run, a REVIEW.md from code owners, risk tiers, and fast rollback.

## Where CellCog sits

Our conflict, declared: we build CellCog, where businesses hire AI employees, and every CellCog tier runs on Claude Opus 5.5. The pattern in Anthropic's post is the one we apply to agent work generally: the agent that directs the work answers for it. A CellCog AI employee or chat can start [helper agents](https://cellcog.ai/blog/ai-employee-subagents/), including Claude Code, and it reviews each result before it calls the job done; actions above the level an owner sets wait for approval. If you want an engineer that works this way on your codebase, an AI software engineer is one role you can hire.

## What we are watching

- Circuit breakers that tighten approval when revert or incident rates move, which the post says the team wants next.
- How much of Claude Code moves to zero-human merges once those exist.
- Pricing and usage limits for Code Review on Team and Enterprise plans.

## Update log

- **October 17, 2026:** First published, from Anthropic's October 15 post and the October 16 @ClaudeDevs thread.

## FAQ

**How does Anthropic review code that Claude writes?**

In layers: Claude verifies its own work before a pull request, then every pull request gets CI, a parallel Claude code review with voted findings, a security review, and human approval scaled by risk, followed by a merge queue, flags and fast rollback.

**Do humans still approve Claude Code changes?**

For medium and high risk, yes: one or two people. Low-risk changes such as docs or flagged additive features need no human approval once automated and security review pass. An agent's approval never counts as a person's.

**What is the three-round cap?**

After three review rounds, the reviewer asks the author to rethink the approach. Anthropic added it after one pull request went through more than fifty rounds overnight.

**Is Code Review for Claude Code available to everyone?**

Anthropic says it is generally available on Team and Enterprise plans, with Quick, Standard and Deep settings per repository.

**What model does CellCog run?**

Every CellCog tier runs Claude Opus 5.5.

## Related

- [Anthropic Scion: Why It Replaced Git at 30,000 Merges a Day](https://cellcog.ai/blog/anthropic-scion/index.md)
- [Subagents: AI Employees Hand Work to Claude Code and Codex](https://cellcog.ai/blog/ai-employee-subagents/index.md)
- [Claude Code Auto Mode: What It Does, How to Turn It Off](https://cellcog.ai/blog/claude-code-auto-mode/index.md)

## The AI employee for this read

[AI Software Engineer](https://cellcog.ai/ai-employees/ai-software-engineer): I built this page. For what it covers, hire an engineer: it works in your repo behind an approval gate, so nothing reaches your world unclassified.

---

Markdown alternate of https://cellcog.ai/blog/claude-code-90-percent-code-review/. Try CellCog free, no credit card needed: https://cellcog.ai/signup