
Verification Loop
- 1.5k installs
- 238k repo stars
- Updated August 5, 2026
- affaan-m/ecc
This is a copy of verification-loop by affaan-m - installs and ranking accrue to the original listing.
verification-loop is a Claude Code skill that runs a repeatable six-phase quality gate for developers who need systematic checks after features complete or before opening pull requests.
About
verification-loop is a comprehensive verification skill from affaan-m/ecc for Claude Code sessions that enforces quality gates in six phases before merge-ready code ships. Phase 1 runs build verification via npm or pnpm build and stops on failure. Phase 2 type-checks TypeScript with npx tsc --noEmit or Python with pyright. Additional phases cover linting, tests, and further gates defined in the skill workflow. Invoke after completing a feature, before creating a PR, after refactoring, or whenever quality gates must pass systematically. Reach for verification-loop when ad hoc checks miss steps and you need a ordered stop-on-failure verification pipeline.
- 6-phase verification checklist that runs after every significant code change
- Hard gate: build must succeed before proceeding to type check, lint, tests, and security
- Combines build verification, TypeScript/Python type checking, linting, test coverage (80% target), and security scans
- Reports test counts, pass/fail rates, coverage percentage, and flags console.log or secret patterns
- Designed for Claude Code sessions with explicit stop-on-failure instructions
Verification Loop by the numbers
- 1,495 all-time installs (skills.sh)
- +99 installs in the week ending Aug 5, 2026 (Skillselion tracking)
- Data as of Aug 5, 2026 (Skillselion catalog sync)
npx skills add https://github.com/affaan-m/ecc --skill verification-loopAdd your badge
Show developers this skill is listed on Skillselion. Paste this into your README.
| Installs | 1.5k |
|---|---|
| repo stars | ★ 238k |
| Last updated | August 5, 2026 |
| Repository | affaan-m/ecc ↗ |
How do you run pre-PR quality gates in Claude Code?
Run a repeatable 6-phase quality gate after finishing features or before opening pull requests.
Who is it for?
Developers finishing features or refactors who want a systematic six-phase verification pipeline before creating pull requests.
Skip if: Production incident response, security penetration testing, or projects without standard build, typecheck, or test scripts.
When should I use this skill?
A feature or significant code change is complete, before creating a PR, after refactoring, or when quality gates must pass in order with stop-on-failure.
What you get
Passed build, typecheck, lint, and test phases with stop-on-failure logs confirming merge readiness.
- passed quality gate report
- stop-on-failure diagnostic logs
By the numbers
- Six-phase verification pipeline
- Supports npm, pnpm, npx tsc --noEmit, and pyright commands
Files
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
# Check if project builds
npm run build 2>&1 | tail -20
# OR
pnpm build 2>&1 | tail -20If build fails, STOP and fix before continuing.
Phase 2: Type Check
# TypeScript projects
npx tsc --noEmit 2>&1 | head -30
# Python projects
pyright . 2>&1 | head -30Report all type errors. Fix critical ones before continuing.
Phase 3: Lint Check
# JavaScript/TypeScript
npm run lint 2>&1 | head -30
# Python
ruff check . 2>&1 | head -30Phase 4: Test Suite
# Run tests with coverage
npm run test -- --coverage 2>&1 | tail -50
# Check coverage threshold
# Target: 80% minimumReport:
- Total tests: X
- Passed: X
- Failed: X
- Coverage: X%
Phase 5: Security Scan
# 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 -10Phase 6: Diff Review
# Show what changed
git diff --stat
git diff HEAD~1 --name-onlyReview 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:
Set a mental checkpoint:
- After completing each function
- After finishing a component
- Before moving to next task
Run: /verifyIntegration with Hooks
This skill complements PostToolUse hooks but provides deeper verification. Hooks catch issues immediately; this skill provides comprehensive review.
interface:
display_name: "Verification Loop"
short_description: "Build, test, lint, and typecheck verification"
brand_color: "#10B981"
default_prompt: "Use $verification-loop to run build, test, lint, and typecheck verification."
policy:
allow_implicit_invocation: true
Related skills
How it compares
Use verification-loop for ordered local pre-PR gates; use CI/CD pipeline skills when checks must run on remote build servers.
FAQ
How many phases does verification-loop include?
verification-loop runs a six-phase quality gate system for Claude Code sessions. Early phases verify builds with npm or pnpm, type-check with tsc or pyright, then continue through linting, tests, and additional gates with stop-on-failure behavior.
When should verification-loop run?
verification-loop should run after completing a feature or significant code change, before creating a PR, or after refactoring. The skill ensures ordered quality gates pass before merge-ready code ships.