Key Takeaways
- Anthropic's Claude Code team says Claude writes about 90% of Claude Code's own code, with merged pull requests more than doubling from June to September 2026 and reverted changes dropping by over 40%.
- The published playbook relies on layered review: broad automated coverage first, then deep review, with humans spending minimal time on the decisions that actually prevent reverts and incidents.
- A core rule is 'You land it, you own it' — whoever merges a change stays accountable for it, which keeps ownership clear when most code is machine-written.
- The full write-up is free to read in a browser on claude.dev, and the team includes guidance on adopting the same process in your own repository.
Quick Facts
| Type | Engineering process write-up and product update |
|---|---|
| Devices | Any device with a modern web browser |
| Price | Free to read; check claude.dev for product pricing |
| Languages | Check the official site for available languages |
| Highlight | Claude writes ~90% of Claude Code's code |
| Learning curve | Easy to read; moderate to apply team-wide |
| Category | Tech Buzz |
| Creator | ClaudeDevs |
| Official site | claude.dev ↗ |
| Heat | 🔥 1.8M Heat |
| Last updated |
What Anthropic Actually Announced About Claude Code
On October 16, 2026, the Claude Code team at Anthropic shared a striking internal statistic: Claude writes about 90% of Claude Code's own code. Claude Code is Anthropic's AI coding assistant, so the tool is effectively maintaining itself with heavy machine involvement. The team paired that claim with outcome data from June to September 2026, when merged pull requests more than doubled and the share of changes sent back for rework fell by more than 40%.
That combination is why the story spread quickly among developers. A high automation rate alone would be easy to dismiss, but the team tied it to fewer reverts, which is the metric most engineers actually feel in daily work. The announcement came with a full write-up on claude.dev explaining how code review had to change to make those numbers possible, rather than presenting the statistic as a standalone stunt.
The authors credited in the write-up are Addy Osmani, Morgan Westlee Lunt, and Qing Wang, publishing as part of the Claude Code team. The piece is framed as a practical playbook rather than a research paper, which matters for readers: it describes process choices any team can copy, not a proprietary model capability you cannot access.
- The headline number
Claude writes roughly 90% of Claude Code's code, according to the team's own account. Treat it as a self-reported figure and read the write-up for how it is measured.
- The outcome metrics
From June to September 2026, merged pull requests more than doubled while the reverted share dropped by over 40%, suggesting review changes kept quality stable as volume grew.
- Who published it
The Claude Code team at Anthropic, with Addy Osmani, Morgan Westlee Lunt, and Qing Wang credited, released the process details openly on claude.dev.
How Layered Review Keeps AI-Written Code Safe
The central idea is that review should be layered by depth rather than applied uniformly. Broad automated checks run first and cover as much of every change as possible, catching mechanical problems cheaply. Only after that does deep review happen, and human attention is deliberately reserved for the smallest possible slice of time that still prevents reverts and incidents. The team describes optimizing for that minimum rather than maximizing hours spent reading diffs.
A second pillar is tracking the full lifecycle of a change, not just the moment it is approved. That means watching what happens after merge, including whether a change gets reverted or causes trouble later. Because the team can see which review decisions correlated with reverts, they can tune the reviewer itself, improving prompts, checks, and guidance over time instead of guessing.
The third pillar is shared context. When most code is machine-written, reviewers lose the intuition that comes from having written the code themselves, so the team emphasizes spreading context across the whole group. Documentation, conventions, and prior decisions become part of the review surface, which is how a reviewer, human or automated, can judge whether a change fits the codebase rather than merely whether it compiles.
- Coverage before depth
Automated checks sweep every change broadly first, so deep human or model review is spent only where it changes the outcome.
- Lifecycle tracking
The team follows changes past merge, using revert and incident data to judge whether review decisions were actually good.
- Context sharing
Team-wide context replaces the intuition reviewers once got from writing code themselves, keeping judgments consistent as volume scales.
- Reviewer improvement loop
Findings feed back into better review guidance, so the process compounds instead of staying static.
The 'You Land It, You Own It' Rule and How to Adopt the Process
The rule developers quote most is 'You land it, you own it.' Whoever merges a change remains accountable for it afterward, regardless of whether a human or Claude wrote the code. That single convention solves a real failure mode of AI-heavy development, where responsibility can dissolve because nobody feels they authored the change. Ownership keeps someone watching the change after it ships.
The write-up also covers how humans stay in the loop and when the team changes direction, which matters because a process built for one codebase does not transfer automatically. The team includes a dedicated section on adopting the process, suggesting you start with the ownership rule and layered review on your next pull request rather than redesigning everything at once. Early wins come from small, visible changes.
For teams experimenting with AI coding assistants, the practical takeaway is to measure reverts, not just throughput. Merged pull requests doubling sounds impressive, but the companion drop in rework is what shows the process held up. If your revert rate climbs as AI-written volume grows, the review layer is the place to fix first.
- Start with ownership
Apply 'You land it, you own it' to your next merge so accountability survives the handoff from assistant to human.
- Pilot on one pull request
Try layered review on a single change before rolling it out team-wide, and compare revert behavior against your current process.
- Watch the right metric
Track the share of changes reverted or reworked, since that reveals whether review quality is keeping pace with AI-generated volume.
Why This Matters Beyond One Team, and What to Watch Next
The story resonates because it reframes the AI coding debate. Instead of asking whether assistants can write code, it asks what engineering process looks like when they already do most of it. Anthropic's answer is unglamorous: layered checks, lifecycle data, shared context, and clear ownership. Those are process disciplines, which means smaller teams can borrow them without access to anything exotic.
There are open questions worth tracking. The 90% figure and the June-to-September improvements are self-reported by the team that built the tool, so independent verification is limited, and the write-up does not claim the approach transfers unchanged to every codebase. How much of the gain comes from better models versus better review is also unresolved, and readers should check claude.dev for the latest details rather than relying on summaries.
For ordinary users of Claude Code, the immediate value is a template. For developers and team leads, it is evidence that review, not raw generation, is the bottleneck to manage as AI writes more of your code. The next signals to watch are whether other teams publish comparable revert data and whether the team updates its guidance as the balance between human and machine review shifts.
- Process over magic
The playbook is mostly disciplined review practice, so it is portable to teams that do not use Anthropic's tools.
- Verify before adopting
The metrics are self-reported; treat them as a strong signal and validate results in your own repository.
- Who it is for
Most useful for engineering teams already merging AI-written code at volume; casual users can read it for context on where the tooling is heading.
Step-by-Step Guide
Read the original write-up on claude.dev
Open claude.dev in any modern browser on a phone or computer. The full article is free to read with no app install or account required, and it takes roughly fourteen minutes to get through.
Work through the sections in order
Follow the table of contents from rethinking the purpose of code review through the layered review, reviewer improvement, human-in-the-loop, context sharing, ownership, direction changes, adoption, and future sections. The order builds the argument step by step.
Apply the ownership rule to your next merge
Adopt 'You land it, you own it' immediately: whoever merges a change stays responsible for it afterward. This costs nothing to try and closes the accountability gap that appears when assistants write most of the code.
Layer your review on one pull request
Run broad automated checks across the whole change first, then reserve deep review and human time for the parts that could cause reverts or incidents. Compare the result against your usual process before scaling up.
Track reverts and iterate
Measure the share of merged changes that get reverted or reworked, and use that data to tune your review guidance. If you want to try the product itself, follow the Try Claude Code path from the official site.
Frequently Asked Questions
Is it true that Claude writes 90% of Claude Code's code?
That is the figure the Claude Code team itself published on October 16, 2026, describing how much of the product's code Claude writes. It is a self-reported internal number rather than an independently audited one, so treat it as a strong signal from the team closest to the work. The accompanying write-up explains the review process behind it.
What do the doubled merged PRs and lower revert rate actually mean?
Between June and September 2026, merged pull requests more than doubled while the share of changes sent back for rework fell by more than 40%. Together they suggest the team handled far more changes without quality slipping, since reverts are a direct sign that a merged change had to be undone. The team credits its revised review process for holding that balance.
Do I need an account or app to read the write-up?
No. The article is published openly on claude.dev and can be read in a browser on a computer or phone without registration or installing anything. Using Claude Code itself is a separate matter and may require an Anthropic account or plan, so check the official site for current terms before signing up.
Can my team copy this review process?
The write-up is written as an adoption guide, and the team suggests starting small with the ownership rule and layered review on your next pull request. The core ideas, broad automated coverage first, deep review second, minimal human time on decisions that prevent reverts, and shared team context, do not depend on any specific tool. Validate the results in your own repository.
What should I watch next on this topic?
Look for whether other engineering teams publish comparable revert and throughput data, which would test how general the approach is. Also watch for updates on claude.dev, since the team frames the process as evolving as the balance between human and machine review changes. The unresolved question is how much of the gain comes from better models versus better review.
