PluginBench
Skill
Fail
Audit score 45

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-loop
Claude Code
Cursor
Windsurf
Cline

How to use verification-loop

  1. 1.Run the skill after completing a feature or significant code change
  2. 2.Execute Phase 1 (Build Verification) using npm run build or pnpm build, stopping if it fails
  3. 3.Execute Phase 2 (Type Check) with npx tsc --noEmit for TypeScript or pyright for Python
  4. 4.Execute Phase 3 (Lint Check) with npm run lint or ruff check
  5. 5.Execute Phase 4 (Test Suite) with npm run test -- --coverage and verify 80% minimum coverage
  6. 6.Execute Phase 5 (Security Scan) to grep for secrets, API keys, and console.log statements
  7. 7.Execute Phase 6 (Diff Review) with git diff commands to review all changed files
  8. 8.Generate and review the verification report showing pass/fail status for each phase

Use cases

Good for
  • 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
Who it's for
  • 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

What should I do if the build fails?

Stop immediately and fix the build errors before continuing to the next verification phase. A failed build blocks all subsequent checks.

What is the target code coverage threshold?

The skill targets a minimum of 80% code coverage. Review coverage reports to identify untested code paths.

How often should I run verification in long sessions?

Run verification every 15 minutes or after completing each function/component as a mental checkpoint.

Can this skill work with both JavaScript and Python projects?

Yes, it supports both. It uses npm/pnpm for JavaScript/TypeScript and pyright/ruff for Python projects.

What is the difference between this skill and PostToolUse hooks?

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.