Anthropic’s Claude Code team published a verification playbook on November 16, 2026 explaining how it checks agent-written code. The article, by Addy Osmani, prioritizes end-to-end, property, and differential tests, then connects those checks to repository-level verification skills and human escalation.
This is implementation guidance, not a new Claude model release. Its practical value is a way to move beyond asking an agent whether its work looks correct: make it run the changed system, collect evidence, and stop when repeated repairs fail.
For engineering teams, the most consequential detail is the separation between a change and the rules used to judge it. A verification loop becomes much less useful if the agent can weaken its checks until its implementation passes.
Why Verification Loops Matter for Coding Agents
The Claude Code team reports that approximately 90% of its code is written and reviewed by Claude. At that level of agent involvement, the team argues that verification loops make it possible to run many agents in parallel without manually checking every output.
Anthropic also reports that a separate grader checking structured-file generation against a rubric improved task success by up to 10 points compared with a standard prompting loop, with the largest gains on difficult tasks. That is an internal result for a specific task category, not an independently measured improvement across software repositories. The guide does not provide enough detail to predict the same gain for a particular engineering team. Source: Anthropic’s guide.
The useful lesson is narrower than the headline number: generation and evaluation benefit from distinct responsibilities. An agent’s explanation of its work is weaker evidence than a check that exercises the behavior being changed.
I’d treat the playbook as a workflow design document. Its strongest contribution is showing how tests, review rules, and escalation can become a repeatable delegation process.
Choose Tests That Expose Different Failure Modes
Anthropic recommends three high-value approaches. They answer different questions, so teams should select them according to the change.
| Test approach | What it checks | Useful application |
|---|---|---|
| End-to-end | Whether a complete user flow works in the running system | Checkout, authentication, navigation, or API workflows |
| Property | Whether a rule holds across many generated inputs | Serialization, normalization, retries, and domain invariants |
| Differential | Whether old and new implementations agree on the same inputs | Migrations, rewrites, and compatibility work |
End-to-End Tests Establish Whether the Feature Works
Osmani’s recommendation is direct:
“If you have to focus on one test type, pick end-to-end.”
The guide uses shopping-cart and checkout flows as examples. A unit test can pass while the assembled feature remains broken. An end-to-end check exercises the connections between components and can produce evidence, such as a screenshot, that shows where a user flow failed.
Anthropic recommends giving the agent access to the running system through tools such as the Chrome DevTools Protocol, simulators, or API harnesses. It also suggests using a feature map as a rubric, including paths, keyboard shortcuts, selectors, and expected results. Source: Anthropic’s testing recommendations.
For implementation, define completion before asking the agent to make the change. “Checkout works” is vague. A stronger check specifies the starting state, the actions to perform, and the final state to inspect.
My view is that this explicitness matters as much as the tool choice. A browser-capable agent still needs a clear definition of success.
Property Tests Challenge the Assumptions Behind the Code
Property tests describe a rule, then generate many inputs that try to break it. Anthropic names fast-check for JavaScript and TypeScript, Hypothesis for Python, and proptest for Rust.
The guide’s examples include:
- Round trips: encoding and decoding a value returns the original value.
- Invariants: a domain constraint remains true.
- Idempotency: repeating an operation has the same effect as performing it once.
- Equivalence: an optimized implementation matches a simpler reference implementation.
These checks can expose edge cases missing from hand-selected examples. Their usefulness still depends on choosing a valid property. An account-balance invariant, for instance, must reflect whether the product permits overdrafts.
A practical consequence is to review the property separately from its implementation. Thousands of generated inputs cannot rescue an incorrect definition of expected behavior.
Differential Tests Make Compatibility Measurable
Differential testing runs the old and new systems with identical inputs and compares their outputs. Anthropic recommends randomly generated inputs or samples of production traffic, normalization of irrelevant differences such as whitespace, and a list of approved behavior changes.
That approved-change list is essential. The old implementation records existing behavior, including quirks and possible bugs. A mismatch therefore needs classification: regression, intended change, or irrelevant variation.
I’d make that classification explicit in migration reviews. Otherwise, an agent may spend its repair budget reproducing behavior the team intended to remove. Normalization deserves review too: ignoring formatting may be appropriate, while ignoring a changed field value could conceal a real compatibility failure.
Build a Repository-Level Verify Skill
The guide recommends putting a verify skill in the repository’s .claude/skills directory so Claude has documented instructions for running a smoke-test harness before committing. A daily.dev summary also describes a commit gate requiring /code-review or /verify.
The skill should explain how to verify this repository, not simply tell Claude to “run tests.” Translate that into concrete information:
- Setup: prerequisites, configuration, test services, and fixture data.
- Execution: the repository’s existing commands and relevant smoke-test flows.
- Expected behavior: the feature map or acceptance criteria.
- Evidence: outputs needed to distinguish a pass from an incomplete run.
- Failure handling: repair limits and escalation requirements.
The following is proposed instruction text to adapt, not an official skill schema or an executed example:
# Verify This Change
- Prepare the documented test environment and fixture data.
- Run the repository's required fast checks.
- Run the smoke-test harness and exercise affected user flows.
- Run relevant property or differential tests.
- Report the checked commit, checks run, results, and failures.
- If a check still fails after three repair rounds, stop and
escalate with the failure evidence.
Replace generic steps with the repository’s actual setup and commands. Include enough context to prevent the agent from mistaking a missing dependency or unavailable service for a product defect.
The distinction between test priority and execution order is useful here. End-to-end coverage can be the most valuable investment while compilation, type checks, linting, and small tests run first. Cheap failures should be caught before an expensive application startup.
Anthropic also warns that flaky tests encourage reruns instead of repairs, while slow tests reduce verification frequency. It recommends heavier tests before committing. Source: Anthropic’s guide.
Escalate After Three Repair Rounds
Anthropic’s workflow stops Claude and brings in a human when a check still fails after three repair rounds. The daily.dev summary of the guide describes the same three-attempt boundary.
Treat this as a control on the repair loop. Repeated failure can signal a misunderstood requirement, unstable environment, unsuitable test, or deeper implementation problem.

Frequently Asked Questions
4 questions
1Is This a New Claude Model Release?
No. The November 16 publication is engineering guidance for verifying Claude Code’s work, including test selection, repository workflows, and review safeguards.