Verification before completion

Stops the agent from saying "done" or "tests pass" until it has rerun the check and read the whole output. Use whenever the agent reports success, commits or opens a pull request.

TestingPack: Superpowers120 linesverification-before-completion
Author
Source
obra/superpowers/skills/verification-before-completion @ 22f0b46
License
MIT · Copyright (c) 2025 Jesse Vincent

About this skill

What it does

The skill stops the agent from saying "done", "fixed" or "tests pass" without proof. Before any such claim, a commit, a PR or the next task, it has to name the command that proves the claim, run it in full right now, read the whole output with the exit code, and only then report — with the evidence. An earlier run, "should pass" or a subagent's word does not count.

The skill is a single SKILL.md, mostly tables. One matches each claim to its evidence: a build needs exit 0, not a clean linter; a fixed bug needs the original symptom retested; a regression test needs a red-green check (revert the fix, watch the test fail); a delegated task needs the VCS diff. The others list the excuses agents use and the words that give an unchecked claim away — "should", "probably", or a "Great" before anything ran. A claim in other words is still a claim.

When to use it, and when not

Use it wherever the agent reports its own results: fixes, test runs, builds, delegated work, plans where each "done" opens the next step — above all once you have caught it claiming success it never checked.

It adds nothing when the agent claims nothing about the work: answering a question or explaining code. In a project with no tests and no build it cannot invent evidence; it only makes the agent say what it could not check.

How to run it

The install command below puts SKILL.md and the licence in place. The agent picks the skill up by its description before it reports success or commits; to call it yourself:

  • Claude Code: /verification-before-completion, or ask for the skill by name.
  • Codex: $verification-before-completion.
  • Cursor: type / in the Agent chat and pick verification-before-completion.

Example: /verification-before-completion Before you push, prove the migration fix works: run the tests and the build and show me the output.

It calls no other skills; executing-plans uses it to accept each task and systematic-debugging before reporting a fix.

How it differs from similar skills

Self-review before PR from our catalog is a checklist over the diff — debug leftovers, secrets, scope, tests, migrations — where "do not claim tests pass unless you ran them in this session" is one line among many. Verification before completion turns that line into a rule for every status message, not only the one before a PR. Release checklist decides whether a release is safe to ship and checks production after the deploy; it does not police what the agent claims along the way. Define a measurable goal settles before the work starts what evidence will prove it done; this skill demands that evidence, freshly run, before every claim. Doubt-driven development takes claims a test run cannot settle, such as "this is safe" or "this scales", and gives them to a fresh-context subagent told to find what is wrong.

Install

Run one command — it saves SKILL.md and the files it uses into your agent's skills folder. Claude Code and Codex pick up a new skill without a restart; if it does not show up, restart the agent.

Claude Code — macOS, Linux
curl -fsSL --create-dirs -o ~/.claude/skills/verification-before-completion/SKILL.md https://anymodel.org/en/skills/superpowers/verification-before-completion/SKILL.md -o ~/.claude/skills/verification-before-completion/LICENSE https://anymodel.org/en/skills/superpowers/verification-before-completion/LICENSE
Codex, Cursor — macOS, Linux
curl -fsSL --create-dirs -o ~/.agents/skills/verification-before-completion/SKILL.md https://anymodel.org/en/skills/superpowers/verification-before-completion/SKILL.md -o ~/.agents/skills/verification-before-completion/LICENSE https://anymodel.org/en/skills/superpowers/verification-before-completion/LICENSE
Claude Code — Windows PowerShell
foreach ($f in 'SKILL.md','LICENSE') { $p = Join-Path "$HOME\.claude\skills\verification-before-completion" $f; New-Item -ItemType Directory -Force (Split-Path $p) | Out-Null; Invoke-WebRequest "https://anymodel.org/en/skills/superpowers/verification-before-completion/$f" -UseBasicParsing -OutFile $p }
Codex, Cursor — Windows PowerShell
foreach ($f in 'SKILL.md','LICENSE') { $p = Join-Path "$HOME\.agents\skills\verification-before-completion" $f; New-Item -ItemType Directory -Force (Split-Path $p) | Out-Null; Invoke-WebRequest "https://anymodel.org/en/skills/superpowers/verification-before-completion/$f" -UseBasicParsing -OutFile $p }

Any other agent: save the file into its skills folder, or give it the link to the file: https://anymodel.org/en/skills/superpowers/verification-before-completion/SKILL.md

SKILL.md

Raw

Verification Before Completion

Overview

Core principle: Evidence before claims, always.

Violating the letter of this rule is violating the spirit of this rule.

The Iron Law

NO COMPLETION CLAIMS WITHOUT FRESH VERIFICATION EVIDENCE

If you haven't run the verification command in this message, you cannot claim it passes.

The Gate Function

BEFORE claiming any status or expressing satisfaction:

1. IDENTIFY: What command proves this claim?
2. RUN: Execute the FULL command (fresh, complete)
3. READ: Full output, check exit code, count failures
4. VERIFY: Does output confirm the claim?
   - If NO: State actual status with evidence
   - If YES: State claim WITH evidence
5. ONLY THEN: Make the claim

Skip any step = lying, not verifying

Common Failures

Claim Requires Not Sufficient
Tests pass Test command output: 0 failures Previous run, "should pass"
Linter clean Linter output: 0 errors Partial check, extrapolation
Build succeeds Build command: exit 0 Linter passing, logs look good
Bug fixed Test original symptom: passes Code changed, assumed fixed
Regression test works Red-green cycle verified Test passes once
Agent completed VCS diff shows changes Agent reports "success"
Requirements met Line-by-line checklist Tests passing

Red Flags - STOP

  • Using "should", "probably", "seems to"
  • Expressing satisfaction before verification ("Great!", "Perfect!", "Done!", etc.)
  • About to commit/push/PR without verification
  • Trusting agent success reports
  • Relying on partial verification
  • Thinking "just this once"
  • Tired and wanting work over
  • ANY wording implying success without having run verification

Rationalization Prevention

Excuse Reality
"Should work now" RUN the verification
"I'm confident" Confidence ≠ evidence
"Just this once" No exceptions
"Linter passed" Linter ≠ compiler
"Agent said success" Verify independently
"I'm tired" Exhaustion ≠ excuse
"Partial check is enough" Partial proves nothing
"Different words so rule doesn't apply" Spirit over letter

Key Patterns

Tests:

✅ [Run test command] [See: 34/34 pass] "All tests pass"
❌ "Should pass now" / "Looks correct"

Regression tests (TDD Red-Green):

✅ Write → Run (pass) → Revert fix → Run (MUST FAIL) → Restore → Run (pass)
❌ "I've written a regression test" (without red-green verification)

Build:

✅ [Run build] [See: exit 0] "Build passes"
❌ "Linter passed" (linter doesn't check compilation)

Requirements:

✅ Re-read plan → Create checklist → Verify each → Report gaps or completion
❌ "Tests pass, phase complete"

Agent delegation:

✅ Agent reports success → Check VCS diff → Verify changes → Report actual state
❌ Trust agent report

When To Apply

ALWAYS before:

  • ANY variation of success/completion claims
  • ANY expression of satisfaction
  • ANY positive statement about work state
  • Committing, PR creation, task completion
  • Moving to next task
  • Delegating to agents

Rule applies to:

  • Exact phrases
  • Paraphrases and synonyms
  • Implications of success
  • ANY communication suggesting completion/correctness

Connect through AnyModel API

This skill runs on whatever model your agent uses. Point Claude Code, Codex or Cursor at AnyModel to run it on Claude, GPT, Gemini and more with one key — pay per token, no subscription.

More from the pack Superpowers

Brainstorming before you build

Finds out what you want to build and why: one question at a time, its understanding played back part by part, two or three approaches to pick from and a design doc, with no code until you approve it. Use for a new feature or change when the request leaves the essentials open.

Dispatching parallel agents

Splits independent problems between parallel subagents, each with one domain and a self-contained brief with scope, constraints and the report expected back, then checks their edits for conflicts and runs the full suite. Use when several unrelated things fail at once.

Executing plans

Runs a plan from writing-plans in the current session with no subagent per task: tasks in order through TDD, a ledger of progress and rulings that survives context compaction, and one fresh review of the whole branch at the end. Use when per-task review is not needed or there are no subagents.

Finishing a development branch

Finishes a branch: runs the tests, offers to merge locally, open a pull request or keep it as is, reruns the tests after a merge and removes its own worktree, and discards work only after you type "discard". Use when the implementation is done.

Receiving code review

Checks each review comment against the code before changing anything, clears up every unclear item first, pushes back with technical reasons and never performs agreement. Use when working through review feedback without blind fixes.

Requesting code review

Hands finished work to a fresh reviewer subagent through a template: the commit range, the plan or requirements, findings by severity and a verdict on merging. Use when a task or feature is done and a merge to main is next.

Subagent-driven development

Executes a plan through subagents: a fresh implementer and reviewer for every task, checking spec compliance and code quality, up to five fix rounds and a final review of the whole branch. Use for a plan of independent tasks when each one needs a review.

Systematic debugging

Keeps the agent from guessing at fixes: reproduce the bug and find the root cause first, test one hypothesis at a time, fix with a failing test, and question the design after three failed fixes. Use for any bug, test failure or unexpected behavior.

Test-driven development, Superpowers style

Drives work test-first: a test seen failing, then the least code that passes and a run of the whole suite; code written before its test is deleted. Use for features and bug fixes when the agent tends to add tests after the code.

Using git worktrees

Moves feature work into an isolated git worktree: checks whether the agent is already isolated, prefers the harness's own worktree tool, keeps the folder git-ignored, installs dependencies and runs a baseline test. Use when the work must not land on the branch you have open.

Writing implementation plans

Turns a spec into a plan for an implementer new to the codebase: files, signatures, interfaces between tasks, tests with exact values and TDD steps with each command's expected output. Use for a multi-step task when the spec is ready and no code exists yet.

Writing skills

Writes and edits skills the TDD way: a subagent first does the task without the skill and its mistakes are written down, then the smallest text that answers them goes in and the loopholes get closed. Use for a skill that other agents will load.