At Anthropic, the Claude Code team has reached a scale where nearly 90% of their codebase is authored and reviewed by AI agents. To maintain quality at this volume, the team has shifted from human-centric review cycles toward 'verification loops'—automated processes where agents verify their own work against specific evidence before a human ever sees a pull request.
The Mechanics of Verification Loops
A verification loop is an iterative cycle where an AI agent checks its own work—running tests, linters, or custom checks—and attempts to fix failures automatically. By automating these steps, the team can run dozens or hundreds of agents in parallel, whereas manual checking limits a developer to overseeing only one or two at a time.
The team prioritizes three specific test types: end-to-end (E2E) tests, property tests, and differential tests. E2E tests are considered the most effective because they describe real user flows, such as adding an item to a cart, and provide definitive 'done' criteria that are difficult for an agent to bypass.

This visual demonstrates why the team prioritizes end-to-end tests, as they provide concrete evidence of failure that is harder for agents to ignore or 'fool'.

The figure supports the claim that E2E tests are the most effective because they provide definitive 'done' criteria and visual evidence.
“Verification loops are the building block that lets you delegate more work to Claude. Without them, you can really only run one or two Claudes at a time, because you have to check everything yourself.”
— How the Claude Code team thinks about verification / claude.dev Blog
Testing for Edge Cases and Invariants
To catch errors that standard prompting might miss, the team employs property tests. These use libraries like `fast-check` or `Hypothesis` to generate thousands of inputs to prove that invariants—such as 'account balances can never become negative'—remain true even in obscure edge cases.
For large-scale migrations where functionality must remain identical, the team uses differential tests. These run both the old and new systems with the same inputs, using the old system as an 'oracle' to identify any discrepancies in the new implementation.
Codifying Rules into Skills
Anthropic codifies these manual checks into 'skills'—markdown files in a `.claude/skills/` folder that define specific behaviors and allowed tools. For example, a 'verify' skill can be used to boot a simulator and inspect an app, providing the agent with 'hands and eyes' on the running system.
To prevent agents from bypassing their own constraints, the team ensures that the verification rules are read from a base branch rather than the pull request itself. This prevents an agent from modifying the very check that judges its output.
Human Intervention and Reliability
While the goal is automation, the system includes a 'human-in-the-loop' trigger: if an agent fails to resolve a check after three rounds of iteration, it stops and requests human attention. This ensures that complex blockers are escalated rather than being ignored.
The team also maintains a reliability checklist with 39 items, each with a trigger that can be read from a diff. Claude reads the diff and checks only the items whose trigger matches—usually 3 to 10—so nobody has to memorize past outages.
What Hacker News readers are saying
- Open question: One commenter expressed concern regarding the high cost of running numerous parallel verification loops, noting that current token expenses for just a few agents are already significant. comment ↗
- Open question: A commenter noted that while the team claims 90% of the code is AI-authored, they expressed a greater interest in understanding the nature of the remaining 10% of the codebase. comment ↗
Summarized opinions from the Hacker News thread, not verified facts. Read the full discussion ↗