# Claude Code Verification: Build a Skill That Checks Real Behavior

A worked verification workflow with owner-approved expectations, a runnable-app checklist and checks that cannot quietly redefine success.

By Paras Madan | 2026-11-17

A coding agent can write a feature and a test that agree with each other while both misunderstand the requirement. Asking it to add more tests does not resolve that problem. Someone still has to define what the application should do.

The Claude Code team's [November 16 verification article](https://claude.dev/blog/how-the-claude-code-team-thinks-about-verification/) emphasizes running changes, owner-written checks and keeping judging rules outside the changes they judge. The useful takeaway is a workflow you can inspect, rather than a particular number of agents or tests.

Here is an original worked example for a small task app. It is a template, not a tested integration: I have not run these checks against an application.

## Write the expected behavior before the patch

Suppose the change adds a Completed filter. The product owner approves a fixture containing three records: A and B both titled “Review draft,” and C titled “Send invoice.” Only B is completed.

The acceptance contract is concrete:

- All shows three records; Completed shows only B; Active shows A and C.
- Marking A complete changes the remaining-active count from two to one.
- Reloading preserves A's completed state.
- Identical titles do not cause both A and B to change together.

Store these expectations in an owner-reviewed document. The duplicate title is deliberate: a happy-path test with unique titles would miss a handler that uses display text instead of record identity.

Before implementation, settle any ambiguous behavior. Should reload preserve the selected filter as well as the records? This example requires record persistence only. The agent should not decide the extra product requirement while fixing a failing check.

## Put the run recipe in a project skill

The current [Claude Code skills documentation](https://code.claude.com/docs/en/skills) already lists a bundled `/verify`. A repository-level skill named `verify` replaces it. Use a distinct name for this example so that choice is explicit.

Save the following as `.claude/skills/verify-todos/SKILL.md`. The file paths and application setup are illustrative; create the referenced contract and replace the recipe with your project's approved local commands before use.

```markdown
---
name: verify-todos
description: Check task filtering and persistence in the running local app.
disable-model-invocation: true
---
Read docs/verification/todos-contract.md and
docs/verification/local-run.md. Do not edit either.

Use only the disposable test environment described there.
Record the commit, working-tree changes and fixture version.
Run the approved launch recipe. If startup or browser access
is blocked, report BLOCKED rather than substituting a build.

Load the three-record fixture. Drive All, Completed and Active.
Check record identities, not titles alone. Complete A and reload.
Compare each observation with the contract.

Report PASS, FAIL or BLOCKED for each requirement, with
actual observations and evidence paths. Preserve first-failure
logs. Do not weaken assertions, skip failures or change fixtures
without owner review. Do not commit, deploy or use production data.
```

Type `/verify-todos` at the start of a Claude Code prompt to invoke it deliberately. The frontmatter disables automatic model invocation, and this custom name does not inherit special pre-commit behavior associated with `verify`. A skill is an instruction recipe, not an enforcement boundary. Protect the acceptance rules through review and trusted CI configuration rather than relying on “do not edit” alone.

## Add checks with different failure modes

A browser run tests the assembled flow. For this example, I would also inspect the persisted records through a separate read-only test helper: A and B should both be completed after the action, while C remains active. That helps distinguish a correct-looking screen from a failed save.

For the filter function, generate records with unique IDs and repeated titles, then check that Active and Completed partition the IDs without losing or duplicating any. Compare results with a small reference implementation the owner reviews separately. Independence comes from how the expected result is established, not merely from starting another agent.

Dan Luu's [Astra testing experiments](https://danluu.com/astra-testing/) provide a useful caution. Results differed across tasks, and the harder Pandoc experiment did not establish a reliable universal ranking of testing techniques. Treat a technique name as a candidate to evaluate, not evidence that the resulting tests are useful. Those experiments also concern Astra, not a measured Claude performance result.

## Review evidence for the exact change

Keep code review and execution separate. Anthropic's [hosted Code Review documentation](https://code.claude.com/docs/en/code-review) says reviews inspect code without building or running it. No findings is not a guarantee of correctness. Use that review to question the implementation, then inspect the running-app evidence independently.

For this workflow, require the final report to identify the tested commit and any uncommitted changes. If the implementation changes after the run, rerun the affected checks. A screenshot from yesterday cannot establish that today's patch persists the right record.

Before making the check mandatory, try a deliberately broken version in a disposable branch, such as one that updates every matching title. Confirm that the check fails for the expected reason. Keep that failure evidence alongside the successful run so reviewers know what the check actually detects.

I'm Paras. I work at the intersection of AI, engineering and distribution.

I help developer-tool teams turn technical practices into guides engineers can apply and evaluate.

[Book a 30-minute call](https://cal.com/paras-madan/30min).
