Guide · Agent skill
How to use the Verification Loop agent skill
Updated · written with AI from the project's own documentation and checked against our catalogue data
The Verification Loop skill is a written checklist that tells Claude Code to verify its own coding work before it says a task is finished. It covers building the project, type checking, linting, running tests, a basic scan for secrets and console.log calls, and a review of the git diff. This guide explains what the skill does, how to install it, how to trigger it, and where its limits are.
Verification Loopaffaan-m/ECC · MIT Download the skill Quick start
- 1Download the skill. Download the verification-loop ZIP from this page and unzip it. Confirm the folder contains SKILL.md.
- 2Choose an install location. Place the folder in ~/.claude/skills/ for personal use, or in .claude/skills/ inside a project. In the Claude apps, upload it under Settings → Capabilities → Skills.
- 3Check your project scripts. Make sure build, lint and test commands run in your project, for example through npm or pnpm, and that TypeScript or Python tools are available.
- 4Finish a coding task. Once the feature or change is done, ask the agent in plain language to verify its work before you open a PR.
- 5Read the report. Review each PASS or FAIL line and the Overall READY or NOT READY verdict.
- 6Fix the listed issues. Work through the numbered Issues to Fix list and run the skill again if needed.
What is an agent skill and what does this one do?
An agent skill is a folder containing a SKILL.md file of instructions that an AI agent reads when a request matches the skill's description. The skill does not add new tools; it tells the agent which commands to run and how to report the results.
The verification-loop skill makes the agent work through six phases before claiming a coding task is complete: build verification, type check, lint check, test suite, security scan and diff review. It then produces a short PASS/FAIL report with a READY or NOT READY verdict for a pull request.
- Build: runs the project build and stops to fix failures.
- Types: runs a type checker (npx tsc --noEmit for TypeScript, pyright for Python).
- Lint: runs the lint script, or ruff for Python.
- Tests: runs the test suite with coverage, with an 80% coverage target.
- Security: greps for patterns such as 'sk-' and 'api_key' and for console.log in src/.
- Diff: reviews git diff output for unintended changes, missing error handling and edge cases.
Install the verification-loop skill
Download the ZIP for the skill from this page and unzip it. The skill folder contains agents/openai.yaml and SKILL.md. Put the folder in one of these locations:
- Personal use across projects: ~/.claude/skills/
- Single project: the .claude/skills/ folder inside your project
- Claude apps: upload the skill under Settings → Capabilities → Skills
Trigger the skill with natural requests
You do not need a special command to start it. The skill's description says to use it when verifying a Claude Code session's work before claiming it is complete, so ask the agent in plain language at the end of a task. The source also lists these moments as good times to invoke it: after a feature or significant change, before creating a PR, when you want quality gates to pass, and after refactoring.
The SKILL.md also describes a /verify command for periodic checks during long sessions. Check that it works in your setup before relying on it.
- "Verify your work before we open a PR."
- "Run the verification loop on these changes."
- "Check whether this refactor is ready for review."
What the report looks like
After running the phases, the agent fills in a fixed report template. Each line shows a status and, where relevant, a count. The report ends with an Overall line that says READY or NOT READY for a PR, followed by a numbered list of issues to fix.
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. ...Requirements and safety notes
The skill needs an agent that can run shell commands, such as Claude Code. Your project needs working build, lint and test scripts (the examples use npm or pnpm), and TypeScript (npx tsc) or Python tools (pyright, ruff). The diff review needs a git repository. The skill runs scripts and does not use the network.
The security step is weak. It is a simple grep for patterns like 'sk-' and 'api_key', so it will miss many real leaks and may flag harmless text. Do not treat a PASS in this step as proof that your code has no secrets. Use a dedicated secret scanner for that job.
- Runs scripts: yes. Uses network: no.
- Projects with no build or test setup will see most steps fail or be skipped.
- The examples cover JavaScript/TypeScript and Python. Other stacks need the agent to adapt the commands itself.
- Review the commands in SKILL.md before you install it, since the agent runs them in your project.
Tips for getting useful results
Set up your build, lint and test scripts before you add the skill, since each failed or missing command makes the report less useful. Run the skill after a logical unit of work rather than only at the very end, so issues are caught while they are small.
The source notes that hooks catch issues immediately, while this skill provides a deeper, more comprehensive review. Use both if your setup supports PostToolUse hooks.
- Keep the coverage target in mind: the skill looks for 80%, and your project may not meet it.
- Read the Issues to Fix list yourself rather than accepting the verdict blindly.
What people use it for
- Checking a TypeScript feature branch for type errors, lint warnings and failing tests before opening a pull request.
- Running a Python project through pyright and ruff as part of a consistent pre-PR check.
- Reviewing a refactor's git diff for unintended changes and missing error handling.
- Giving a team a standard format for reporting test, type and lint status.
Frequently asked questions
Is the verification-loop skill free?
The skill is released under the MIT licence, as stated in its SKILL.md. The source does not list any price, so check the licence terms in the repository for details.
What do I need to install the verification-loop skill?
Download the ZIP from this page and unzip it into ~/.claude/skills/ or a project's .claude/skills/ folder, or upload it in the Claude apps under Settings → Capabilities → Skills. You also need an agent that can run shell commands, such as Claude Code.
Does the skill need a network connection?
No. The skill runs local scripts and commands and is listed as not using the network. It does run commands in your project, so review SKILL.md before installing.
Can the verification-loop skill find all secrets in my code?
No. Its security step is a simple grep for patterns like 'sk-' and 'api_key'. It will miss many leaks and can flag harmless text, so use a dedicated secret scanner as well.
Does this skill work with languages other than JavaScript, TypeScript and Python?
The examples only cover JavaScript/TypeScript and Python. For other languages or tools, the agent would need to adapt the commands itself, and results are not guaranteed.
How is this different from hooks?
According to the SKILL.md, hooks such as PostToolUse catch issues immediately, while this skill provides a more comprehensive review. The two are meant to complement each other.
New agent skills, repos and AI tools — every week
The best new skills and open-source projects, the fastest-growing repos, and one free prompt. Five minutes to read. Unsubscribe anytime.
Our verdict
Use this skill if you work in Claude Code on a project that already has build, lint and test commands, and you want the agent to run the same checks and report them in a standard format before a pull request. Pick something else if your project has no build or test setup, or if you need reliable secret detection, since this skill's checks are basic.
Download the skill