Skip to main content
skill CX Codex

verify · pwguler — Claude Code skill: what it checks and how to install

verify — a skill for Claude Code checks claims about completed or fixed work against fresh command output. It runs before a commit or PR, after changes, and before reporting that work is done or tested.

MIT 1,000 installs ★ 10 updated 2026-10-16

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add pwguler/skills --skill verify -a claude-code
Open on GitHub

What verify does

verify asks the agent to name the claim, run the relevant tests, build, or linter, and read the output. It also exercises the changed path end to end; for an app interface, the run should produce saved evidence such as command output or a screenshot. A short task with no spec uses the plan’s criterion as its gate.

When docs/specs/<slug>.md exists, the skill checks its criteria separately and compares the diff with the spec’s exclusions. Evidence applies only to the matching file tree: editing a tracked file invalidates the record. Claims about design, UI, naming, or prose go to the rubric skill, since passing commands cannot establish quality. Skipped checks must be reported as skipped.

What it helps with

  • back a fix claim with fresh test output
  • run the build and linter before a commit
  • exercise a changed app path end to end
  • match verification results to spec criteria
  • report partial checks without claiming the work is done

Example prompts for the agent

  • Check that the fix works, run the relevant commands, and show their output.
  • Run the required checks before the commit and report what they show.
  • Update the app’s verification recipe when asked, then exercise the changed path.

How to install verify

1Skills CLI (Vercel)

npx skills add pwguler/skills --skill verify -a claude-code

2Manually: put the files in place

~/.claude/skills/verify/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/verify/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about verify

How do I install verify in Claude Code?

Run npx skills add pwguler/skills --skill verify -a claude-code. The skill file is at ~/.claude/skills/verify/SKILL.md.

What does verify do?

It requires fresh command output to support claims that work is done, fixed, or passing. It also exercises the changed path and tracks which criteria have evidence.

How does verify handle a project spec?

It checks the criteria in docs/specs/<slug>.md against their verification results and compares the diff with the spec’s exclusions. Criteria without proof remain open.

Source text

SKILL.md · MIT
---
name: verify
description: Prove a claim of done, fixed, or passing before you make it. Run the commands and read their output. Read this skill before you say that work is done, fixed, or tested. Read it also after a small change. Use it before a commit or a PR. Use it also when the user asks to write or update the verification recipe of the app.
---

Evidence comes before a claim. Do not make a claim without a fresh command run behind it.

Fast path: when the plan is one sentence and there is no spec file, the gate is that sentence's criterion. Run only the tests that exercise the change, and still run the changed path end to end. When the gate fails a second time on a fast-path task, the task was not obvious. Stop, and run `drill` on it.

1. Name the claim that you are about to make: "done", "fixed", "passes", or "works".
2. Sort the claim. Verify here what a command can settle. Send a claim about quality to the `rubric` skill now, whatever the commands show. A claim about quality is about a design, a UI, a public interface, a name, or prose. To fail it as unprovable is a routing failure. Passing commands never pass it.
3. Run the commands that would prove the claim false: the tests, the build, the linter, and the behavior that changed. The full gate is every test, the build, and the linter. It runs once for each commit, on the tree that you are about to commit. On the fast path, the gate is the criterion of the sentence. Inside a slice, the test loop runs only the tests that exercise the slice. Inside a phase that the spec declares, a commit uses the checks of the area that it touches. The last commit of the phase runs the full gate.
4. When a spec exists at `docs/specs/<slug>.md`, gate each criterion separately. At the commit of a slice, gate the criteria that the slice touches. A criterion where a declared phase ends waits for the last commit of the phase. When you claim that the whole work is done, gate every criterion. Take each result from the last evidence record when its hash still matches the tree. Run the verification command of each criterion, and quote the output that proves it. For a criterion whose line names `rubric`, use the verdict of that judge. When you claim that the whole work is done, the criteria are items in the current task list. When no list exists and there are three criteria or more, create one. Mark an item done only on the output or the verdict that proves it. A criterion without proof stays open. Then check the diff against the non-goals of the spec. A change inside excluded scope fails the claim, even when the tests pass. A spec that still has an `## Open decisions` section is a draft. No claim stands against a draft. Send it back to `drill`.
5. Exercise the changed path end to end, not only its unit tests. When the change has a runtime interface, drive it, and keep what it showed. A runtime interface is a UI, a CLI, a TUI, or a service. Keep the command output, the logs, a screenshot, or a transcript. When the base branch has a recipe, drive the touched features with it, as [app-check.md](references/app-check.md) says. The recipe is a project skill named `verify-<app>`. Write or update that recipe only when the user asks, through the same reference. For a runtime interface with no recipe, offer in one line to write one. Read [prove it works](references/prove-it-works.md) when you read the result of the changed path through a proxy. A proxy is a timestamp, a status file, a cached value, a screenshot, or a report from another agent. Read it also when a check fails, or when the work is a port or a migration.
6. Read the output. Passing means that the output says passing, not that the command exited.
7. State what you ran and what it showed. If it broke, say that it broke, and show the output. When the spec names a demo artifact, run that artifact again to show the demo. Do not describe an earlier run. A demo shows that the change works, but it proves no criterion. So a script written on the branch can be the demo.

Rules:

- The default answer is reject. A claim is false until fresh output proves it. The word of the implementer is not evidence.
- Never make a claim from memory of an earlier run. The evidence record is the content hash of the working tree, plus each command and its saved output. Get the hash with `git ls-files -z -co --exclude-standard -- . ':!*.md' | sort -z | xargs -0 sha1sum | sha1sum`. On macOS, use `shasum` instead of `sha1sum`. When a test reads Markdown, remove the `':!*.md'` exclusion. A record whose hash matches the tree is fresh output, not memory. Use it again, and do not run its commands again. A commit, a switch back to the same tree, or an edit only to Markdown keeps the hash and record. `implement`, `debug`, `land`, and this skill use the record again. The next edit to a file in the hash makes the record invalid.
- Plan every command that a claim needs, and run each command once, in a single call. Then map the output onto the criteria. Each command writes its full output to a file: `> /tmp/verify-<hash>-<name>.log 2>&1`. Read and search that file. To run a command again to see more of its output is a duplicate run. Run independent commands at the same time. Commands are independent when they share no file, port, database, or build directory. A criterion is a reading of output that already exists, not another start of the test suite.
- A verification command is the test runner, the build, or the linter of the project. A script written on the same branch as the change is not a verification command. Reject a claim that depends on such a script, even when the script passes. A `verify-<app>` recipe counts only in the form that the base branch has. A recipe written or changed on the branch under claim is a script of that branch.
- Report a skipped check as skipped. Partial verification gets a partial claim. "Tests pass; behavior not exercised" is honest. "Done" is not.
- A claim that depends on a measured number states what limits the number, as [explain the number](references/explain-the-number.md) says. A measured number is a benchmark, a speedup, a latency, a size, a pass rate, or a count of runs.
- Review feedback is a claim. Verify it before you implement it. Check unclear feedback. Do not obey it without a check.

© pwguler · MIT · pwguler/skills

Similar skills

All skills for Testing and QA →

verify by other authors comes first.

verify react verify validates code changes against React repository requirements before committing. Runs Prettier, linter, Flow type checks, and tests. CX Codex +1 1,200installs verify Yeachan-Heo verify turns "it should work" into evidence you can read: which check ran, what passed, and what stayed unverified. CX Codex +1 721installs verify official anthropics verify — a skill for Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI and OpenCode that tests harness changes end-to-end without Docker. CX Codex +1 257installs verify codewithmukesh verify — a skill for Claude Code, Codex, Cursor, and other agents that runs a seven-phase verification pipeline on .NET projects: build, analyzers, antipattern detection, tests, security, formatting, and diff review. CX Codex +1 4,000installs verify plastic-labs The verify Claude Code skill tests Honcho changes against a running local app. It exercises the HTTP API, deriver queue, and SQL query plans. CX Codex +1 172installs verify-and-stop JuliusBrussee verify-and-stop proves existing work meets acceptance criteria without expanding scope. Useful for validation tasks and last-mile checks. CX Codex +1 129,000installs verify-this cursor The verify-this skill tests a specific claim against fresh local evidence: it captures before and after measurements, compares artifacts, and returns one verdict. CX Codex +1 2,600installs audit-verify-explain-grade-5 MengTo audit-verify-explain-grade-5 — a skill for Claude Code, Codex, Cursor, GitHub Copilot, and Gemini CLI that checks every claim against real evidence and delivers the result in plain language. CX Codex +1 1,700installs gsd-verify-work open-gsd gsd-verify-work is a Claude Code skill that runs conversational user acceptance testing for completed features. Validates changes test by test and outputs a markdown report. CX Codex +1 594installs vibe-verify KhazP The vibe-verify skill exercises a running product against acceptance criteria and reports evidence. A passing build on its own proves nothing about behavior. CX Codex +1 ★ 3,267repo stars verify-counts ldayton The verify-counts skill compares numeric claims in documentation against the real values and flags the outdated ones. Handy when a README still promises 14,000+ tests. CX Codex +1 ★ 244repo stars

From the same set15

The whole set →
parallel This Claude Code skill runs independent tasks through subagents in parallel. It activates only when asked to parallelize work, compare attempts, or split a job into parts. CX Codex +1 1,000installs core-interview core-interview — a skill for Claude Code that runs an interview loop through decision trees until every branch is settled. CX Codex +1 1,000installs research The research Claude Code skill traces library and API behavior to primary sources, or investigates why code took its current shape. It activates for lookups and questions about the history of a setting or constant. CX Codex +1 1,000installs debug debug is a Claude Code and Cursor skill that traces bug root causes step by step and verifies regression tests. CX Codex +1 1,000installs land land is a Claude Code skill that finishes a development branch through merge, PR, keep, or discard. It runs after implementation is complete. CX Codex +1 1,000installs drill A skill for Claude Code interviews the user about a plan or design until its decisions are settled. It runs for new features, unresolved designs, or a request to “drill this.” CX Codex +1 1,000installs implement implement — a skill for Claude Code and Codex that executes settled plans in thin test-driven slices. Runs when prompted to build code from a spec or slice plan. CX Codex +1 1,000installs rubric rubric — a skill for Claude Code finds defects in changes and judges design, interface, or writing quality. It sets evaluation criteria before asking an independent subagent to inspect the work. CX Codex +1 980installs

Project sponsors

Companies that keep this analytics open