verification-loop
affaan-m/ecc
Comprehensive verification system for Claude Code sessions covering builds, types, lints, tests, and security.
What is verification-loop?
A multi-phase verification workflow that checks build status, TypeScript/Python types, linting, test coverage, security issues, and code diffs. Use this after completing features, refactoring, or before creating pull requests to ensure quality gates pass.
- Phase 1: Build verification to catch compilation errors
- Phase 2: Type checking for TypeScript and Python projects
- Phase 3: Lint checking with language-specific tools
- Phase 4: Test suite execution with coverage reporting (80% target)
- Phase 5: Security scanning for secrets and console.log statements
- Phase 6: Diff review to identify unintended changes and edge cases
How to install verification-loop
npx skills add null --skill verification-loopHow to use verification-loop
- 1.Run the build verification command (npm run build or pnpm build)
- 2.Execute type checking (npx tsc --noEmit for TypeScript or pyright for Python)
- 3.Run linting checks (npm run lint or ruff check)
- 4.Execute test suite with coverage reporting (npm run test -- --coverage)
- 5.Perform security scan for secrets and console.log statements
- 6.Review git diff to identify changed files and potential issues
- 7.Generate and review the verification report with overall status
Use cases
- Run after completing a feature to verify all quality gates pass
- Execute before creating a pull request to catch issues early
- Use after refactoring to ensure no regressions were introduced
- Run periodically during long coding sessions (every 15 minutes) as a checkpoint
- Review changed files for unintended modifications and missing error handling
- TypeScript/JavaScript developers using Claude Code
- Python developers using Claude Code
- Teams enforcing code quality standards
- Developers working on projects with test coverage requirements
verification-loop FAQ
Stop immediately and fix the build errors before continuing to the next verification phase.
The skill targets a minimum of 80% code coverage for the test suite.
Run verification every 15 minutes or after completing each major change like finishing a function or component.
Yes, it includes language-specific commands for both TypeScript/JavaScript (npm, tsc, eslint) and Python (pyright, ruff) projects.
It searches for API keys (sk- prefix), api_key strings, and console.log statements that should not be in production code.
Full instructions (SKILL.md)
Source of truth, from affaan-m/ecc.
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/ecc and the wider catalog.
video-editing
AI-assisted editing pipeline for cutting, structuring, and augmenting real video footage.
videodb
Ingest, index, search, and edit video and audio with real-time desktop capture and live stream monitoring.
visa-doc-translate
Translate visa documents to English and generate bilingual PDFs automatically
vite-patterns
Vite build tool patterns for config, plugins, HMR, and optimization.
vue-patterns
Agent skill from affaan-m/ecc.
windows-desktop-e2e
E2E testing for Windows native desktop apps (WPF, WinForms, Win32/MFC, Qt) via pywinauto and UI Automation.