Verification Loop
Run a fixed six-step agent workflow—build, types, lint, tests, security grep, and diff review—before you open a PR or call a feature done.
Overview
verification-loop is an agent skill most often used in Ship (also Build) that runs six ordered verification phases—build, types, lint, tests, security scan, and diff review—before you treat work as merge-ready.
Install
npx skills add https://github.com/affaan-m/everything-claude-code --skill verification-loopWhat is this skill?
- Six verification phases: build, type check, lint, test suite with coverage, security scan, and diff review
- Hard stop if build fails—no later phases until the project compiles again
- TypeScript (tsc) and Python (pyright) type-check paths with truncated error reporting
- Lint via npm run lint or ruff; tests with pass/fail counts and coverage summary
- Security pass greps for sk- prefixes, api_key strings, and stray console.log in src
- 6 verification phases
- 80% minimum coverage target
Adoption & trust: 5k installs on skills.sh; 210k GitHub stars; 2/3 security scanners passed (skills.sh audits).
What problem does it solve?
You finished a feature or refactor but lack a consistent pre-PR checklist, so broken builds, type errors, or leaked keys slip through casual agent runs.
Who is it for?
Solo builders on npm/pnpm TypeScript or Python repos who want the coding agent to execute the same quality gates every time before merge.
Skip if: Repos without standard build/lint/test scripts, pure infra-only changes with no app toolchain, or teams that already enforce identical checks exclusively in CI and forbid local agent runs.
When should I use this skill?
After completing a feature or significant code change; before creating a PR; when you want quality gates to pass; after refactoring.
What do I get? / Deliverables
You get a structured pass/fail report across build, lint, tests, and basic security greps so you fix blockers before opening a PR.
- Verification phase reports (build, types, lint, tests, security grep)
- Coverage and pass/fail summary
Recommended Skills
Journey fit
Spans multiple journey phases - primary shelf plus alternate fits below.
Canonical shelf is Ship because the skill is explicitly for quality gates and pre-PR verification, even though it executes right after Build work finishes. Testing is the best fit: it drives test runs, coverage reporting (80% target), and stops the loop on build/type failures before merge.
Where it fits
After adding API routes, run the loop so build and typecheck fail fast before you document the feature.
Before opening a PR, execute all six phases and record test pass counts and coverage against the 80% target.
Use the diff-review phase as structured input right before human or agent code review.
After a production hotfix branch, rerun verification to ensure lint and tests still pass on the patch.
How it compares
Use as a repeatable local pre-PR ritual instead of asking the agent to improvise which npm scripts to run each session.
Common Questions / FAQ
Who is verification-loop for?
It is for solo and indie developers using Claude Code, Cursor, or Codex who ship TypeScript or Python apps and want agent-driven verification before PRs.
When should I use verification-loop?
After completing a feature or significant code change, before creating a PR, when quality gates must pass, and after refactoring—typically at the end of Build work and at the start of Ship.
Is verification-loop safe to install?
It instructs the agent to run shell commands and grep your repo; review the Security Audits panel on this page and ensure you are comfortable with local build/test execution.
SKILL.md
READMESKILL.md - Verification Loop
# Verification Loop Skill A comprehensive verification system for Claude Code sessions. ## When to Use Invoke this skill: - After completing a feature or significant code change - Before creating a PR - When you want to ensure quality gates pass - After refactoring ## Verification Phases ### Phase 1: Build Verification ```bash # Check if project builds npm run build 2>&1 | tail -20 # OR pnpm build 2>&1 | tail -20 ``` If build fails, STOP and fix before continuing. ### Phase 2: Type Check ```bash # TypeScript projects npx tsc --noEmit 2>&1 | head -30 # Python projects pyright . 2>&1 | head -30 ``` Report all type errors. Fix critical ones before continuing. ### Phase 3: Lint Check ```bash # JavaScript/TypeScript npm run lint 2>&1 | head -30 # Python ruff check . 2>&1 | head -30 ``` ### Phase 4: Test Suite ```bash # Run tests with coverage npm run test -- --coverage 2>&1 | tail -50 # Check coverage threshold # Target: 80% minimum ``` Report: - Total tests: X - Passed: X - Failed: X - Coverage: X% ### Phase 5: Security Scan ```bash # Check for secrets grep -rn "sk-" --include="*.ts" --include="*.js" . 2>/dev/null | head -10 grep -rn "api_key" --include="*.ts" --include="*.js" . 2>/dev/null | head -10 # Check for console.log grep -rn "console.log" --include="*.ts" --include="*.tsx" src/ 2>/dev/null | head -10 ``` ### Phase 6: Diff Review ```bash # Show what changed git diff --stat git diff HEAD~1 --name-only ``` Review each changed file for: - Unintended changes - Missing error handling - Potential edge cases ## Output Format After running all phases, produce a verification report: ``` VERIFICATION REPORT ================== Build: [PASS/FAIL] Types: [PASS/FAIL] (X errors) Lint: [PASS/FAIL] (X warnings) Tests: [PASS/FAIL] (X/Y passed, Z% coverage) Security: [PASS/FAIL] (X issues) Diff: [X files changed] Overall: [READY/NOT READY] for PR Issues to Fix: 1. ... 2. ... ``` ## Continuous Mode For long sessions, run verification every 15 minutes or after major changes: ```markdown Set a mental checkpoint: - After completing each function - After finishing a component - Before moving to next task Run: /verify ``` ## Integration with Hooks This skill complements PostToolUse hooks but provides deeper verification. Hooks catch issues immediately; this skill provides comprehensive review.