> ## Documentation Index
> Fetch the complete documentation index at: https://mintlify.com/obra/superpowers/llms.txt
> Use this file to discover all available pages before exploring further.
# Verification Before Completion
> Run verification commands and confirm output before making any success claims - evidence before assertions, always
Claiming work is complete without verification is dishonesty, not efficiency. This skill enforces the iron law: **no completion claims without fresh verification evidence.**
## Core Principle
**Evidence before claims, always.**
If you haven't run the verification command in this message, you cannot claim it passes.
**Violating the letter of this rule is violating the spirit of this rule.**
## The Iron Law
```
NO COMPLETION CLAIMS WITHOUT FRESH VERIFICATION EVIDENCE
```
This is non-negotiable. No exceptions. Ever.
## The Gate Function
What command proves this claim?
Execute the FULL command (fresh, complete)
Full output, check exit code, count failures
Does output confirm the claim?
* If NO: State actual status with evidence
* If YES: State claim WITH evidence
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
Stop immediately if you're:
* 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)
```
For regression tests, you **must** verify the test fails without the fix and passes with it. A test that never fails proves nothing.
### 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
```
## Why This Matters
From 24 failure memories:
* Your human partner said "I don't believe you" - trust broken
* Undefined functions shipped - would crash
* Missing requirements shipped - incomplete features
* Time wasted on false completion → redirect → rework
* Violates: "Honesty is a core value. If you lie, you'll be replaced."
## 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
## Real-World Examples
**Wrong:**
```
I've fixed the bug. The tests should pass now.
```
**Right:**
```bash theme={null}
npm test
```
```
✓ 47 tests passing
0 failures
All tests pass. Bug is fixed.
```
**Wrong:**
```
The linter passed, so the build should be fine.
```
**Right:**
```bash theme={null}
npm run build
```
```
Build completed successfully (exit 0)
Output: dist/bundle.js (245KB)
Build passes.
```
**Wrong:**
```
All tests pass, so we've met the requirements.
```
**Right:**
```
Re-reading plan from docs/plans/auth-feature.md:
✓ 1. User login via OAuth - Implemented in auth.ts:15-42
✓ 2. Session management - Implemented in session.ts:8-31
✓ 3. Token refresh - Implemented in refresh.ts:12-28
✗ 4. Logout endpoint - NOT FOUND
Requirements NOT met. Missing logout endpoint (requirement 4).
```
**Wrong:**
```
Agent reported success. Task complete.
```
**Right:**
```bash theme={null}
git diff HEAD~1
```
```
Agent changed:
- src/parser.ts: Added parseJSON function
- tests/parser.test.ts: Added 3 test cases
Running tests:
✓ 3/3 new tests pass
✓ 47/47 total tests pass
Agent task verified complete.
```
## Correct Phrasing
* "All tests pass" (after showing test output)
* "Build succeeds" (after showing build output)
* "Fixed" (after showing test passing)
* "Complete" (after showing checklist)
* "Should work"
* "Looks good"
* "Probably fixed"
* "Seems correct"
* "Done!" (without verification)
## The Bottom Line
**No shortcuts for verification.**
Run the command. Read the output. THEN claim the result.
This is non-negotiable.
## Related Skills
* [Requesting Code Review](/skills/requesting-code-review) - Request reviews with verified evidence
* [Finishing a Development Branch](/skills/finishing-a-development-branch) - Complete work with test verification