Now liveThe Skillselion MCP - thousands of ranked skills, loaded into your agent mid-task. No install.Get it →
affaan-m avatar

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-loop

Add your badge

Show developers this skill is listed on Skillselion. Paste this into your README.

Listed on Skillselion
Installs1.5k
repo stars238k
Last updatedAugust 5, 2026
Repositoryaffaan-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

SKILL.mdMarkdownGitHub ↗

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

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.

Testing & QAtestingintegrations

This week in AI coding

Five minutes, every Monday - the tools, releases and tactics for developers.

unsubscribe anytime.