Verification Gate

Name: Verification Gate
Author: learnprompt

learnprompt/cc-harness-skills

57 installs
231 repo stars
Updated July 10, 2026
learnprompt/cc-harness-skills

Helps with ai & agent building tasks.

About

verification-gate is a Claude Code skill for ai & agent building. It helps solo builders move faster with AI-assisted coding.

verification-gate
AI & Agent Building
AI-coding skill

Verification Gate by the numbers

57 all-time installs (skills.sh)
+2 installs in the week ending Aug 2, 2026 (Skillselion tracking)
Ranked #6,658 of 16,546 AI & Agent Building skills by installs in the Skillselion catalog
Data as of Aug 2, 2026 (Skillselion catalog sync)

npx skills add https://github.com/learnprompt/cc-harness-skills --skill verification-gate

Add your badge

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

[![Listed on Skillselion](https://skillselion.com/badge/skills/learnprompt/cc-harness-skills/verification-gate.svg)](https://skillselion.com/skills/learnprompt/cc-harness-skills/verification-gate)

Installs	57
repo stars	★ 231
Last updated	July 10, 2026
Repository	learnprompt/cc-harness-skills ↗

What it does

Helps with ai & agent building tasks.

Files

SKILL.mdMarkdownGitHub ↗

Verification Gate

Use this skill when the implementation should not be accepted without a separate challenge pass.

Use It For

post-implementation verification
checking whether claimed tests really ran
finding edge cases before reporting completion
converting "looks done" into "verified" or "unverified"

Quick Start

Collect a verification context from a git repo:

python3 {baseDir}/scripts/verification_context.py --repo /path/to/repo

Then run the portable verifier prompt from references/prompt-template.md.

Verifier Rules

default to read-only
findings first
never imply validation ran if it did not
distinguish verified, unverified, and failed

Supporting Files

Prompt template: references/prompt-template.md
Source notes: references/source-notes.md
Helper script: python3 {baseDir}/scripts/verification_context.py ...

CC Verification Gate

verification-gate is a portable read-only review skill that checks whether an implementation is actually done.

It is designed for the moment after coding appears complete: gather context, inspect what changed, and force a separate verification pass to label the result as verified, unverified, or failed.

Best For

post-implementation verification
checking whether tests truly ran
edge-case review before reporting completion
preventing optimistic false-finish messages

Included Files

SKILL.md
references/prompt-template.md
references/source-notes.md
scripts/verification_context.py

Quick Start

python3 ./scripts/verification_context.py --repo /path/to/repo

Then run the verifier workflow from SKILL.md.

Host Fit

Claude Code: strong fit
Codex: strong fit
OpenClaw: workable, but strongest when the host supports a separate verifier pass

Portable Prompt Template

You are a verification gate for a completed implementation.

Inputs:
- task summary: <task_summary>
- claimed validation: <claimed_validation>
- diff or changed files: <verification_context>

Rules:
- default to read-only review
- challenge completion claims instead of trusting them
- findings come before summary
- if validation was not run, say so directly

Check:
1. does the change match the request
2. is there evidence that validation really ran
3. are there obvious regressions or edge cases
4. is anything overstated as "done"

Return:
1. findings ordered by severity
2. what was actually verified
3. what remains unverified
4. whether the work should be considered complete

#!/usr/bin/env python3
"""Collect lightweight git context for a verification pass."""

from __future__ import annotations

import argparse
import json
import subprocess
from pathlib import Path
from typing import Any


def run_git(repo: Path, *args: str) -> str:
    proc = subprocess.run(
        ["git", *args],
        cwd=repo,
        capture_output=True,
        text=True,
        check=False,
    )
    return proc.stdout.strip()


def build_context(repo: Path) -> dict[str, Any]:
    return {
        "repo": str(repo),
        "status": run_git(repo, "status", "--short"),
        "diff_stat": run_git(repo, "diff", "--stat"),
        "changed_files": run_git(repo, "diff", "--name-only").splitlines(),
        "head": run_git(repo, "rev-parse", "--short", "HEAD"),
        "branch": run_git(repo, "rev-parse", "--abbrev-ref", "HEAD"),
    }


def main() -> int:
    parser = argparse.ArgumentParser()
    parser.add_argument("--repo", default=".")
    parser.add_argument("--json", action="store_true")
    args = parser.parse_args()

    context = build_context(Path(args.repo).expanduser().resolve())
    if args.json:
        print(json.dumps(context, indent=2, ensure_ascii=False))
        return 0

    print(f"repo: {context['repo']}")
    print(f"branch: {context['branch']}")
    print(f"head: {context['head']}")
    print("status:")
    print(context["status"] or "  <clean>")
    print("diff_stat:")
    print(context["diff_stat"] or "  <none>")
    print("changed_files:")
    for item in context["changed_files"]:
        print(f"  - {item}")
    return 0


if __name__ == "__main__":
    raise SystemExit(main())