PluginBench
Skill
Fail
Audit score 45

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

How to use verification-loop

  1. 1.Run the build verification command (npm run build or pnpm build)
  2. 2.Execute type checking (npx tsc --noEmit for TypeScript or pyright for Python)
  3. 3.Run linting checks (npm run lint or ruff check)
  4. 4.Execute test suite with coverage reporting (npm run test -- --coverage)
  5. 5.Perform security scan for secrets and console.log statements
  6. 6.Review git diff to identify changed files and potential issues
  7. 7.Generate and review the verification report with overall status

Use cases

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

What should I do if the build fails?

Stop immediately and fix the build errors before continuing to the next verification phase.

What is the target test coverage threshold?

The skill targets a minimum of 80% code coverage for the test suite.

How often should I run this verification in long sessions?

Run verification every 15 minutes or after completing each major change like finishing a function or component.

Does this skill work with both JavaScript and Python projects?

Yes, it includes language-specific commands for both TypeScript/JavaScript (npm, tsc, eslint) and Python (pyright, ruff) projects.

What does the security scan check for?

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.