Catalog
affaan-m/verification-loop

affaan-m

verification-loop

A comprehensive verification system for Claude Code sessions.

global
New~608
v1.1Saved May 11, 2026

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.

Files1
1 files · 1.0 KB

Select a file to preview

Overall Score

78/100

Grade

B

Good

Safety

82

Quality

72

Clarity

85

Completeness

68

Summary

This skill guides AI agents through a six-phase verification system for code quality in Claude Code sessions. It covers build verification, type checking, linting, test execution with coverage reporting, security scanning for secrets and console.log statements, and git diff review. The skill provides structured guidance on what to check and how to report results, with clear pass/fail criteria and a standard output format for verification reports.

Detected Capabilities

shell executionbuild/test command invocationgrep pattern matchinggit operationsfile readingoutput reporting

Trigger Keywords

Phrases that MCP clients use to match this skill to user intent.

verify before PRpre-commit quality checkcoverage validationbuild verificationlint and type checkdetect secrets

Risk Signals

INFO

grep for API key patterns (sk-, api_key) in codebase

Phase 5: Security Scan
INFO

Recursive grep across project (grep -rn) for secrets detection

Phase 5: Security Scan
INFO

Shell piping and output truncation (head, tail, wc -l) for command output

Multiple phases
INFO

Git diff operations on committed changes

Phase 6: Diff Review

Use Cases

  • Verify code quality before submitting a pull request
  • Comprehensive test coverage validation after completing a feature
  • Detect accidentally committed secrets or console.log statements
  • Monitor code across multiple check phases during long development sessions
  • Validate type safety and linting standards after refactoring
  • Review git diffs to catch unintended changes in modified files

Quality Notes

  • Clear phase-based structure makes the verification process easy to follow
  • Provides both npm and pnpm build alternatives, showing awareness of multiple package managers
  • Includes Python project support (pyright, ruff) alongside JavaScript/TypeScript
  • Well-defined output format gives agents a clear template for reporting results
  • Uses sensible command flags (--noEmit, --coverage, tail/head) to limit output and avoid overwhelming logs
  • Explicitly states when to STOP (if build fails) and provides conditional guidance
  • Coverage threshold (80% minimum) is clearly documented
  • No explicit error handling documented for cases where commands are unavailable (e.g., npx tsc when TypeScript is not installed)
  • Phase 5 security scan is basic (pattern matching only) and would miss obfuscated or encoded secrets
  • No guidance on what constitutes 'critical' vs 'non-critical' type errors
  • Continuous mode section is vague ('every 15 minutes') — no concrete monitoring mechanism provided
  • No handling documented for monorepo structures or project subdirectories
  • Diff review phase provides no automated detection of risky patterns (unsafe operations, breaking changes)
Model: claude-haiku-4-5-20251001Analyzed: May 11, 2026

Reviews

Add this skill to your library to leave a review.

No reviews yet

Be the first to share your experience.

Version History

v1.1

Content updated

2026-04-20

Latest
v1.0

Seeded from github.com/affaan-m/everything-claude-code

2026-03-16

Add affaan-m/verification-loop to your library

Command Palette

Search for a command to run...

affaan-m/verification-loop | SkillRepo