verification-loop
affaan-m/everything-claude-code
Comprehensive verification system for Claude Code sessions covering builds, types, linting, tests, security, and diffs.
What is verification-loop?
A structured verification workflow that runs through six phases (build, type check, lint, tests, security, diff review) to ensure code quality before creating PRs. Use this after completing features, refactoring, or significant changes to catch issues early and maintain quality gates.
- Runs build verification to ensure project compiles
- Performs type checking for TypeScript and Python projects
- Executes linting checks with configurable rules
- Runs test suite with coverage reporting (80% minimum target)
- Scans for secrets, API keys, and debug statements
- Reviews git diffs to identify unintended changes
How to install verification-loop
npx skills add https://github.com/affaan-m/everything-claude-code --skill verification-loopHow to use verification-loop
- 1.Run the skill after completing a feature or significant code change
- 2.Execute Phase 1 (Build Verification) using npm run build or pnpm build, stopping if it fails
- 3.Execute Phase 2 (Type Check) with npx tsc --noEmit for TypeScript or pyright for Python
- 4.Execute Phase 3 (Lint Check) with npm run lint or ruff check
- 5.Execute Phase 4 (Test Suite) with npm run test -- --coverage and verify 80% minimum coverage
- 6.Execute Phase 5 (Security Scan) to grep for secrets, API keys, and console.log statements
- 7.Execute Phase 6 (Diff Review) with git diff commands to review all changed files
- 8.Generate and review the verification report showing pass/fail status for each phase
Use cases
- After completing a new feature to verify it builds and passes all checks
- Before creating a pull request to ensure quality gates pass
- After refactoring code to catch regressions and type errors
- During long development sessions as periodic checkpoints every 15 minutes
- When onboarding to a new codebase to understand test coverage and code quality standards
- Full-stack developers using Claude Code
- Teams enforcing code quality standards
- Developers working on TypeScript/JavaScript or Python projects
- Anyone preparing code for peer review
verification-loop FAQ
Stop immediately and fix the build errors before continuing to the next verification phase. A failed build blocks all subsequent checks.
The skill targets a minimum of 80% code coverage. Review coverage reports to identify untested code paths.
Run verification every 15 minutes or after completing each function/component as a mental checkpoint.
Yes, it supports both. It uses npm/pnpm for JavaScript/TypeScript and pyright/ruff for Python projects.
Hooks catch issues immediately during development, while this skill provides comprehensive review across all quality gates before PR submission.
Full instructions (SKILL.md)
Source of truth, from affaan-m/everything-claude-code.
name: verification-loop description: "A comprehensive verification system for Claude Code sessions." metadata: origin: ECC
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 -20
If 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 -30
Report 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 -30
Phase 4: Test Suite
# 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
# 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
# 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:
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.
Related skills
More from affaan-m/everything-claude-code and the wider catalog.
security-review
Security checklist and patterns for authentication, input validation, secrets, and sensitive features.
golang-patterns
Idiomatic Go patterns, best practices, and conventions for building robust, efficient, and maintainable applications.
coding-standards
Baseline coding conventions for naming, readability, immutability, and quality across projects.
frontend-patterns
React and Next.js patterns for components, state management, performance, and modern frontend practices.
backend-patterns
REST/GraphQL API design, database optimization, and server-side patterns for Node.js, Express, and Next.js.
golang-testing
Go testing patterns: table-driven tests, subtests, benchmarks, fuzzing, and TDD methodology.