On November 16, 2026, the Claude Code team published How the Claude Code team thinks about verification: a playbook for letting agents prove work with tests and recorded evidence instead of humans reading every diff. Addy Osmani writes that roughly 90% of Claude Code team code is written and reviewed by Claude, and that verification loops—not stacking reviewers—are what make dozens or hundreds of parallel agents tolerable.
If you run Claude Code on production repos, the actionable shift is architectural: treat verify skills, tamper-proof review files, and observe-mode commit gates like production security controls, not optional niceties.
| Question | Short answer |
|---|---|
| Am I affected? | Yes if you already delegate multi-file changes to Claude Code without an evidence step beyond unit tests |
| Is there a fix? | No CVE—adopt Anthropic’s patterns: verify skill, default-branch REVIEW.md, reliability checklist triggers, observe then enforce gates |
| Does data leave my machine? | Verification itself is local (tests, simulators, MCP browsers); model calls still go to Anthropic as usual |
| What should I do today? | Add a verify skill, run E2E smoke before merge, keep review rules off the PR branch, start a commit gate in observe mode |
explainx.ai’s Jas Sekhon–Anthropic hiring piece situates the same week’s Claude messaging around epistemic rigor; Beam focuses on the verification mechanics Anthropic documents for its own harness. Separately, Runta FrontierHarness v1.1 shows most harness spend can land on failed trials that still read as done—verification loops are how you catch that pattern before merge.
Why verification became the bottleneck
Anthropic’s framing is blunt: without verification, you can only babysit one or two agents. With it, you delegate because the harness returns artifacts you can audit—logs, screenshots, failing steps, property counterexamples—instead of prose claiming success.
Internal tests cited in the post used a separate grader with a rubric on structured file generation. That loop reportedly lifted success by up to 10 points over plain prompting, with the largest gains on the hardest tasks. The mechanism is familiar from classical CI: cheap-to-run checks that agents can regenerate and re-run without burning context on human explanation.
Anthropic also argues agents can close the loop: a failing test about user data in logs becomes a hook rule or CLAUDE.md line so the same mistake is less likely on the next task. That is the same class of feedback Google GTIG documented when attackers edited .claude/settings.json—except here the loop is intentional and owned by the team.
Three test types worth the investment
Anthropic ranks end-to-end (E2E), property, and differential tests ahead of large unit-test suites that agents can satisfy without shipping working features.
End-to-end tests first
E2E tests describe real user flows—checkout, onboarding, permission prompts. Anthropic’s point is that they are hard to fool: either the feature works across the stack or it does not, and failures can include screenshots and step traces where a unit test only shows a timeout string.
Image: Anthropic Claude Code team
The post recommends giving agents hands and eyes on a running system: Chrome extension for web, mobile MCP for iOS/Android, computer use for desktop, or local service harnesses for backend work. Feature maps double as rubrics—paths, selectors, shortcuts, expected outcomes.
Property tests for edge cases humans miss
Property tests state an invariant (“decode(encode(x)) == x”, balances never negative, idempotent migrations) and let libraries like fast-check, Hypothesis, or proptest hunt counterexamples. Anthropic positions them as bias breakers: the generator is not the same mind that wrote the implementation.
Differential tests for migrations
For large rewrites, run old and new systems on the same inputs—sampled production traffic or generated payloads—and flag divergences. Normalize whitespace, maintain an approved-differences list, and treat unexpected drift as a release blocker.
Across all three, Anthropic warns about flaky and slow tests: flaky suites teach agents to retry, slow suites reduce iteration depth. Heavy checks belong pre-commit, lightweight signal belongs in the inner loop.
How the Claude Code team operationalizes verification
The post is explicit about process, not just test taxonomy.
Run the app, not only the test binary
Anthropic states that running the app end to end matters more than green unit tests alone—you would not ship iOS without a simulator pass. Teams should codify that in a verify skill in .claude/skills/, kept close to the code it exercises, and iterate until the skill is fast and reliable.
Failures route humans; fixes stay automated first
When checks fail, Claude attempts repair. If a check is still red after three rounds, Claude stops and escalates to a person. That is a concrete service-level objective you can mirror in how to vibe-code safely with Beam: automate recovery until a fixed attempt budget, then require eyes.
Code owners own checks
The people who own a surface write the checks and tune them until they flag what the owner would flag. When a check pulls a reviewer, it should say why, not force archaeology on the diff.
Reliability checklist triggered by diffs
Anthropic maintains a 39-item reliability checklist. Each item has a diff trigger, a check, and institutional memory from past incidents. Example from the post: when session storage or message types change, ask whether --resume loads old transcripts safely. Claude applies only the 3–10 items whose triggers match—nobody memorizes the full list.
One reviewer, multiple grounded rounds
Instead of stacking expensive reviewers, Anthropic uses REVIEW.md to focus a primary reviewer and carry context forward across rounds rather than re-litigating everything.
Tamper-proof review rules
If a change can modify the check that judges it, the check is broken. Code Review reads REVIEW.md from the default branch, never from the PR head. Reviews are tied to commits, not moving targets while someone keeps pushing.
Cheap checks run before opening a PR: tests, build, linter. Hooks or /goal targets can enforce “green suite before PR”.
Commit gate: off, observe, enforce
Anthropic stamps commits with how they were verified, including explicit “none” for queries. A commit gate can require /code-review or /verify in-session before commit:
- Observe — log would-be blocks, tune false positives.
- Enforce — block commit; after two blocks in a session, allow pass-through so agents do not deadlock (Claude Code is not perfect).
That pattern rhymes with Beam’s observe versus enforce documentation: prove policy in observe before denying real work—except Beam’s deny is hook-based, not Anthropic’s git gate.
Evaluating the evaluators
The team tracks reverts, pre-merge rejections, and clean controls. Code Review runs fixed incident-derived evals with one-sentence answer keys; only findings that name the real bug score. They measure recall before and after verification so bugs are not “found then dropped.”
Review output is also graded for severity, not only correctness: findings can be tagged Important, Nit, or Pre-existing, so agents are not blamed for bugs that predated the diff. The team tunes recall until the next tweak would overfit evals rather than catch production issues.
Missed bugs become rules: patterns from comments and reverts must hit two PRs, survive three disprove attempts, and earn human approval. Flaky tests must be fixed or deleted with rationale—no infinite retry. Rules and skills get routine pruning so the harness stays lean.
What developers are saying
OtherShrezzing critiques cost: per-change verification via skills plus browser tooling is token-expensive compared with cheaper deterministic scripts—a fair pushback for teams without Anthropic-scale budgets.
koolba disagrees that nobody can review every change, arguing small batch sizes keep human review feasible—the same decomposition Anthropic implicitly requires so E2E and property tests stay tractable.
What this means if you run AI coding agents
Anthropic’s post is not a product toggle you flip in claude --version. It is a repo and harness design checklist:
- Author a verify skill with boot commands, ports, and smoke paths; version it beside the code it protects.
- Prefer one strong E2E over dozens of shallow unit tests agents can game.
- Add property or differential checks on parsers, billing, migrations—where agents hallucinate edge behavior.
- Keep REVIEW.md and gate config on protected branches; scan for surprise edits like you would for settings.json hook backdoors.
- Start commit gates in observe mode; query your VCS for unverified commits before enforce.
- Cap auto-fix rounds (Anthropic uses three) then require human sign-off—aligns with NIST-style agent control practices.
Commands you can run today on your machine (from your own repo, not invented here):
claude --version
git log --oneline -20 --grep='verified'
find .claude/skills -name 'SKILL.md' 2>/dev/null | head
If you use Beam, run beam skills scan on any verify skill you add—agents load skills before acting, and skill scanning catches prompt-injection shapes that should not live in a smoke-test playbook.
What Beam can and cannot do here
Beam can record PreToolUse denials and tool traces when agents run tests or shells, scan skills and MCP configs (11 heuristics plus version-pin checks) before load, and keep evidence on-device with redaction before storage—useful when a verify skill wraps curl, npx, or browser drivers.
Beam cannot execute your test matrix, grade screenshots, or enforce Anthropic’s commit gate. It is not a CI system and not semantic test analysis. Missing cached workspace policy is fail-open on hooks; verification quality still lives in your repo’s checks.
For product context see /#how and coding assistant security.
Frequently asked questions
The FAQ in front matter mirrors common search questions; see those entries for quick answers.
Related reading
- Introducing Beam: local-first agent security
- Monitor vs block for coding agents
- Stop dangerous commands in Claude Code
- Cloudflare security-audit skill: run it safely
- Agent baseline secure software factory limits
Primary sources: Anthropic verification post, October code review post linked from the same site.
Technical details and Anthropic process descriptions are accurate as of November 17, 2026. Beam is a local prototype; always confirm harness behavior against your installed Claude Code version.

