Agent Self Verification Gate

The Problem

Your agent says "All done!" and moves on. You check the code five minutes later: it doesn't compile. The build fails because it added a function with the wrong import path. Or it says "tests passed" but it never actually ran them — it just assumed they would pass. Or it changed three files when it meant to change one, silently modifying your config while "fixing" a bug in your auth module.

This is the silent-success problem — the single biggest failure mode in agentic coding workflows. The model reports success because it genuinely believes it finished. But it didn't verify. It didn't build. It didn't run the tests. It didn't check the git diff to confirm it only changed what it intended to change. The developer wastes 15-30 minutes discovering what the agent should have caught in 30 seconds.

What You Get

• Five-check verification gauntlet — Build Check (does it compile?), Test Check (do existing tests pass?), Lint Check (is the code clean?), Git Diff Audit (did I change what I think I changed?), Runtime Smoke Test (does it actually work?)
• Language-specific verification commands — auto-detects Python (py_compile + pytest + ruff), TypeScript (tsc --noEmit + jest + eslint), Go (go build + go test + golangci-lint), Rust (cargo check + cargo test + cargo clippy), Ruby (ruby -c + rspec + rubocop), Java (gradlew compile + test + checkstyle)
• Structured verification report — every check produces a ✅/❌ result with specific output (test counts, error messages, file lists), and a Final Verdict (READY / NEEDS ATTENTION)
• Three-attempt retry cycle — agent tries to fix each failing check up to 3 times before escalating to the user; honest failures preferred over fabricated green checkmarks
• Git diff audit discipline — lists every changed file, confirms each was intentional, flags unintentional changes, removes leftover debug code, and checks for unresolved TODOs
• Runtime smoke testing — curls API endpoints, runs CLI tools with sample input, executes scripts with expected exit codes, validates config files parse correctly

Why This Beats Prompting It Yourself

"You said it compiled, did you actually run the build?" requires you to know what commands to run, remember to ask, and verify the output yourself. The self-verification gate runs automatically — the agent cannot declare "done" until all five checks pass. It catches the most expensive category of silent failures: the ones where the agent genuinely believes it succeeded but didn't verify. Without the gate, the developer becomes the QA department for their own agent.

Example Session

User: "Add input validation to the create_user function in auth.py"

Agent (work complete, verification triggers automatically):

Check 1 — Build: `python -m py_compile auth.py` → ✅ No syntax errors
Check 2 — Tests: `python -m pytest tests/test_auth.py` → ✅ 12 passed
Check 3 — Lint: `ruff check auth.py` → ⚠️ 1 error: unused import 're'
  → Removed unused import, re-ran: ✅
Check 4 — Git Diff:
  auth.py: 15 lines added, 0 removed → intentional ✅
  tests/test_auth.py: 3 lines added (import update) → intentional ✅
Check 5 — Runtime:
  python -c "from auth import create_user; print(create_user('test@x.com', 'weak'))"
  → Returns validation error as expected ✅

### Verification Report
### Check 1: Build ✅
### Check 2: Tests ✅ (12 passed)
### Check 3: Lint ✅ (1 unused import removed)
### Check 4: Git Diff ✅ (2 files, both intentional)
### Check 5: Runtime ✅ (validation error returned correctly)
### Final Verdict: READY

Verification complete. Added email format validation and minimum password 
length check to create_user(). Ready for review.

Without the gate: Agent says "Done!" → developer discovers TypeScript error in their IDE 5 minutes later → 15 minutes wasted tracing the issue.

Use Cases

• Every code change — trigger after any agent-generated modification, no matter how small (a one-line import change can break the build)
• Multi-file refactoring — catch broken imports, unintentional changes, and cascading test failures across the entire change set
• CI/CD pre-commit — ensure agent output is verified before it reaches the commit stage
• Junior developer quality gate — catch unverified agent output before it reaches code review
• Agent output auditing — review verification reports to identify patterns of agent failure across a team

Known Limitations

The gauntlet checks for new issues introduced by the current change — it does not fix pre-existing build failures, test failures, or lint errors unless the user explicitly asks. If no build system, test framework, or linter exists in the project, the agent runs syntax checks at minimum and states which checks could not be performed. The gate cannot verify visual correctness (UI rendering) or runtime performance.