verification-loop
Enables your agent to run a complete code verification cycle. It compiles, tests, and analyzes code, producing a pass/fail report.
What it does
Checks if the code you wrote is good. It verifies if the project builds, has no type errors, follows style rules, passes tests, and doesn't contain sensitive information or unnecessary code.
When to use it
- ✓After completing a new feature.
- ✓Before submitting your code for review.
- ✓When you want to ensure the code is high quality.
Example of what to ask your AI
“Verify my code before submitting it for review.”
Want more? Open the sections below.
How to use
The easiest way: copy the message below and paste it into Claude, ChatGPT, Cursor or any AI. It reads the skill and follows the instructions.
Skill link
Ready-to-paste message
How it works
The system runs several automated checks on your code. It builds, checks types, analyzes style, runs tests, and looks for security issues and leftover code.
Installation
Easiest way: copy the skill link and paste it into Claude, ChatGPT or Cursor asking it to follow the instructions.
In the terminal (Claude Code, Codex, Cursor), in your project folder:
npx skills add affaan-m/ECC --skill verification-loopOr download just the file:
curl -L https://raw.githubusercontent.com/affaan-m/ECC/main/pi/core/skills/verification-loop/SKILL.md -o SKILL.mdTechnical content (original SKILL.md)
Original text by the author, straight from GitHub.
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
set -o pipefail # report the build's exit status, not tail's
# 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
set -o pipefail
# TypeScript projects
npx --no-install tsc --noEmit 2>&1 | sed -n '1,30p'
# Python projects
pyright . 2>&1 | sed -n '1,30p'
Report all type errors. Fix critical ones before continuing.
Phase 3: Lint Check
Use sed to limit displayed output while consuming the whole stream. This keeps a
successful linter from failing on SIGPIPE when pipefail is enabled.
set -o pipefail
# JavaScript/TypeScript
npm run lint 2>&1 | sed -n '1,30p'
# Python
ruff check . 2>&1 | sed -n '1,30p'
Phase 4: Test Suite
set -o pipefail
# 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.
FAQ
What happens if something fails?
If any check fails, the system will tell you what the problems are so you can fix them before proceeding.
Does this replace human review?
No, this tool helps find common issues automatically, but human review is still important for overall quality assurance.
What programming languages does it check?
It is designed to check projects in TypeScript, JavaScript, and Python.
Details
Original description by the author
Run a six-phase verification of a Claude Code session's work — build, type check, lint, tests with coverage, security grep, and diff review — then produce a PASS/FAIL verification report. Use when verifying work after completing a feature or refactor, before creating a PR, or when quality gates must pass.
repo: affaan-m/ECC
Popularity
- GitHub stars
- 280k
- Ranking position
- #130
- License
- MIT
- Updated
- 10/15/2026
Comments
- …
More skills from this repository
accessibility
Helps your agent create interfaces that everyone can use. Ensures websites and apps work well for people with disabilities, like those who are blind or have reduced mobility.
affaan-m/ECC
agent-architecture-audit
Makes your agent check if everything is working correctly. It finds and fixes problems in AI systems, ensuring they perform as expected.
affaan-m/ECC
agent-eval
Helps your agent compare different AI coding tools. It measures which one is faster, cheaper, and more reliable for specific tasks.
affaan-m/ECC
agent-harness-construction
Makes your agent better understand how to perform tasks. It optimizes the tools and instructions the agent uses to increase its chances of success.
affaan-m/ECC
Similar skills
webapp-testing
Allows testing local web applications, verifying functionality, and debugging interface behavior. Captures screenshots and browser logs.
anthropics/skills
ponytail-audit
Performs a complete code audit. It finds bugs, security flaws, slow code, and suggests what to remove or improve.
DietrichGebert/ponytail
ponytail-review
Reviews the quality of a code change. It checks if the logic is correct, safe, fast, and if all lines are necessary.
DietrichGebert/ponytail