· via Hacker News – Front Page (native)
Anthropic's Claude Code team explains how verification loops let it hand 90% of code to AI
The Claude Code team says roughly 90% of its code is now written and reviewed by Claude, and lays out the E2E, property and differential tests plus review process that make large-scale AI delegation safe.

Anthropic's Claude Code team has published a detailed account of how it verifies work produced by AI agents, revealing that roughly 90% of the code on the team is written and reviewed by Claude. In the post, published on claude.dev and surfaced on Hacker News' front page, the team argues that verification loops — giving agents real evidence that their change works — are the core mechanism that makes delegation at that scale possible.
Verification is what buys parallelism
According to the post, a developer without a verification setup can only supervise one or two agent sessions at a time, because every output needs a human eyeball. Cheap, agent-requestable checks — tests, benchmarks, specs and full end-to-end runs — change that equation: once agents can prove their own work, dozens or hundreds can run in parallel.
The team cites internal testing on structured file generation in which a separate grader scored Claude's output against a rubric, improving task success by up to 10 points compared with a standard prompting loop, with the largest gains on the hardest problems. Once generated, these checks run as ordinary software, so they can be executed frequently at little token cost.
The loop should also close on itself: if an agent repeatedly fails a check that scans logs for user data, the team's remedy is a hook or a more explicit rule in the project's CLAUDE.md so the failure mostly stops recurring.
Three tests worth the investment
The post warns that poorly chosen tests backfire. Flaky tests teach the agent to rerun rather than fix the code; slow tests reduce how often an agent checks its work across a batch; heavier tests belong just before a commit.
Three categories get the team's endorsement:
- End-to-end tests. These simulate real user journeys, such as adding an item to a cart and completing checkout. They are hard to fool — the feature either works or it does not — and they produce concrete evidence, like a screenshot describing what broke, where a unit test might only report a timeout. Agents can be given hands-on access to the running system through the Chrome DevTools Protocol, simulators or API harnesses, with a feature map acting as a grading rubric.
- Property tests. Write an invariant that should never fail, then let a library such as fast-check, Hypothesis or proptest generate thousands of inputs that try to break it. Typical properties include encode/decode round trips, invariants like a balance never going negative, idempotent migrations, and equivalence between optimized and naive implementations. Because the edge cases are machine-generated, they lack the bias of the agent that wrote the original code, which makes them especially useful for rewrites where the spec has drifted from production behavior.
- Differential tests. Run the old and new systems on identical inputs — randomly generated or sampled from production traffic — and treat any divergence as a bug or breaking change. These suit large migrations where behavior should stay the same; the team normalizes irrelevant factors like whitespace and keeps a list of approved, intentional differences.
How the team verifies its own changes
The Claude Code team treats actually running the change as more important than static checks: Claude is expected to boot and exercise the app the way a QA engineer would, using the Claude Chrome extension for web changes, iOS or Android MCPs for mobile, computer use for desktop, or a local run for backend work. This is codified in a "verify" skill stored in the repo's .claude/skills/ folder, which the team deliberately keeps fast and reliable. According to the post, this is how nearly all changes at Anthropic are tested.
Humans are brought in through failure. Claude runs the checks and attempts fixes, and if a check still fails after three rounds, it stops and escalates to a person. Checks are written by the people who own the code and refined until they flag exactly what the owner would flag, with each check explaining why it pulled in a reviewer.
A 39-item reliability checklist backs this up. Every item pairs a trigger that can be read from a diff with a check and the incident or pull request behind it. Claude reads the diff and evaluates only the three to ten items whose triggers match, so nobody has to memorize past outages.
On reviews, the team prefers tuning a single reviewer over stacking multiple expensive ones, guided by a REVIEW.md describing what matters for that code. Successive review and verification rounds build on context from earlier passes rather than rechecking everything from scratch. A final guardrail: a change is not allowed to modify the checks that gate it.
Why it matters
The post is a concrete data point on how AI-first teams are reorganizing engineering around verification rather than authorship. If a team inside Anthropic can safely route 90% of its code through Claude, the bottleneck is no longer writing software but building fast, trustworthy checks — end-to-end harnesses, property generators, differential rigs, owner-authored rules — that produce evidence instead of impressions. For anyone using agentic coding tools, the practical lesson is that sustained investment in verification machinery, not prompting alone, is what buys both parallelism and safety.
- #ai-agents
- #claude
- #anthropic
- #testing
- #code-review