verification-before-completion（完成前的验证）

Overview

The verification-before-completion skill is the terminal checkpoint for every task in the toolkit. It enforces a strict 5-step protocol that requires running fresh verification commands, reading their full output, and confirming results match the completion claim. Without this skill, agents make unverified claims that lead to broken code in production — with it, every completion claim is backed by evidence.

Iron Law

NO COMPLETION CLAIMS WITHOUT FRESH VERIFICATION EVIDENCE.

You cannot say "it works," "it's done," "the bug is fixed," or "the feature is complete" without running verification commands and reading their output in this session. Cached results, previous runs, and assumptions do not count.

Phase 1: Identify Verification Commands

Before running anything, explicitly list what needs to pass for this specific task:

Action: List which of these apply to the current project. Not all projects have all types. Be explicit about what you will run and why.

STOP: Do NOT proceed to running commands until you have identified ALL applicable verification types.

Phase 2: Run Commands Fresh

Execute every verification command identified in Phase 1.

STOP: All commands must complete before proceeding to Phase 3.

Phase 3: Read Full Output

Read the entire output of each verification command. Pay attention to:

STOP: Do NOT proceed if you have not read the full output of every command.

Phase 4: Verify Output Matches Claim

Ask yourself these questions. ALL must be "yes" to proceed:

STOP: If ANY answer is "no" or "unsure", go back to fix and restart from Phase 1. Do NOT proceed to Phase 5.

Phase 5: Claim Completion with Evidence

Only now may you say the task is complete. Include this evidence:

VERIFICATION EVIDENCE
=====================
Task: [what was being done]
Date: [timestamp]

Commands Run:
  [x] Tests:      [command] -> [result: X passed, Y failed, Z skipped]
  [x] Build:      [command] -> [result: success/failure]
  [x] Lint:       [command] -> [result: X errors, Y warnings]
  [x] Type-check: [command] -> [result: X errors]
  [x] Format:     [command] -> [result: clean/X files to format]

All Green?  [x] YES  [ ] NO
New warnings introduced?  [ ] YES  [x] NO

Completion claim: [specific claim, e.g., "Feature X is implemented and all tests pass"]

STOP: This is the end of the verification protocol. Only claims with this evidence are valid.

Decision Table: What Counts as "Fresh" Evidence

Decision Table: Edge Cases

Common Failure Patterns

Anti-Patterns / Common Mistakes

Anti-Rationalization Guards

Do NOT claim completion without Phase 5 evidence. There are zero exceptions.

Integration Points

Integration Flow

[Do the work using other skills]
    |
    v
[Think you are done?]
    |
    v
[Invoke verification-before-completion]
    |
    +-- All checks pass -> Claim completion with Phase 5 evidence
    |
    +-- Any check fails -> Fix and re-verify (do NOT claim completion)

Enforcement by Other Skills

This skill is invoked by ALL other skills at completion time. It is not optional. It is a terminal checkpoint — called at the end of work, never at the beginning.

Skill Type

RIGID — The 5-step protocol is a HARD-GATE. Every step must be executed in order. No step may be skipped. No completion claim is valid without Phase 5 evidence. Do not relax these requirements for any reason.