Code Gauntlet

Adversarial multi-agent code review for Claude Code. Your PR runs a gauntlet: parallel concern-specialized reviewers find issues, then every finding must survive deterministic verification, skeptical validation, and a blind challenge before it reaches you. Formerly published as deep-review.

How it reviews

Seven discovery agents examine your changes in parallel, each through a different lens:

Security always runs on Opus because models have complementary vulnerability-class detection profiles.

Discovery is only the entrance. Each finding then runs the gauntlet:

1. Merge — finding-ID deduplication across channels, schema validation, agent attribution
2. Verify — deterministic git-blame classification (new vs. surfaced code) and factual verification against the actual source, trusted only through a nonce + SHA + count receipt
3. Validate — an independent validator attempts to disprove each finding with its full content and codebase access, adjusting confidence either way
4. Filter — confidence and severity thresholds, prompt-injection filtering, cross-agent semantic dedup, consensus boosts, disagreement suppression, routing to the main report or improvement suggestions
5. Blind challenge — a fresh agent attempts to disprove each finding without the original reasoning or evidence; claims it cannot verify from the code are removed
6. Deliver — deterministic ranking and selection, posted verbatim

Only findings that survive every stage get delivered. Anything that fails is eliminated, downgraded, or routed to a lower tier — and every degradation (a failed agent, an untrusted verification) is recorded as an explicit gap in the report rather than silently absorbed.

Benchmark results

Development is gated by a judged benchmark (bench/): golden PRs from real open-source repos with independently established findings, scored by a pinned judge using symmetric three-bucket adjudication (golden-matched / valid-extra / noise). Published tools are re-scored under the same judge as anchors.

Code Gauntlet beats every anchor on recall and noise simultaneously. Measured at the v3 release gate (July 2026, judge pinned to claude-opus-4-5-20251101; runs subset-20260721-015119 and holdout-20260721-085348 in the ledger). The interactive report — per-PR buckets, per-dimension recall, cost, judge drift — is generated by bench/report.py; see the published benchmark report.

Installation

claude plugin marketplace add https://github.com/liatrio-labs/claude-code-gauntlet.git
claude plugin install code-gauntlet@code-gauntlet

To update later:

claude plugin update code-gauntlet@code-gauntlet

Requires Claude Code >= 2.1.154 (the pipeline runs through the dynamic Workflow tool), git, and either the gh CLI (GitHub) or glab CLI (GitLab). The deterministic pipeline scripts use standard-library Python 3 only.

Usage

The skill triggers automatically when you ask for a code review:

# Review a PR (GitHub)
code gauntlet PR #42

# Review a merge request (GitLab)
review MR !89 thoroughly

# Review local uncommitted changes
comprehensive review of my changes

# Focused review
code gauntlet PR #42, focus only on security and error handling

Or invoke it directly:

/code-gauntlet

Key capabilities

• Concern-parallel, not file-parallel — each agent sees the full diff with cross-file context, because bugs at module boundaries are invisible to file-scoped reviewers.
• Full-codebase investigation — agents actively trace data flows beyond the diff via Read/Grep/LSP rather than receiving a passive context dump.
• New vs. surfaced findings — git blame distinguishes issues in code you wrote from pre-existing issues your changes exposed; surfaced findings are downgraded and grouped separately so they don't drown out real ones.
• Incremental review — re-reviewing a PR with new commits offers to review only the delta since the last review.
• Prompt-injection defense — code under review is untrusted input: trust-boundary delimiters on the way in, injection filtering on the way out.
• GitHub and GitLab — platform auto-detected from the git remote.
• Flexible delivery — PR/MR comments, markdown file, chat, task board, or any combination, with user-controlled finding selection for task creation.

Configuration: REVIEW.md

Code Gauntlet offers to scaffold a REVIEW.md when it doesn't find one, mirroring your CLAUDE.md locations — a root file for global defaults, subdirectory files for per-area standards (say, stricter security for src/auth/). Thresholds override child-to-parent; rules and ignore patterns accumulate.

## Rules
- All database queries must use parameterized statements

## Ignore
- security:"prompt injection via template tokens" (not exploitable here, 2026-03-24)

## Skip
- "vendor/**"

## Confidence Threshold
70

The skill maintains the ignore list as you dismiss findings. Full specification, including hierarchy rules: review-md-spec.md. The companion /build-review-md skill walks you through initial setup.

Architecture

A review runs in eight phases. Phases 1–2 happen in your session; phases 3–8 are the internal stages of one deterministic program — the skill makes a single Workflow tool invocation and workflows/pipeline.js takes it from there:

1. Pre-flight — eligibility (not closed, draft, or already reviewed), configuration gate, session SHA resolution
2. Target & triage — platform detection, diff fetch, risk classification, test discovery, CLAUDE.md/REVIEW.md context, shared context file
3. Summarize & discover — change summary, then the parallel discovery agents (schema-enforced structured output)
4. Merge & verify — gauntlet stages 1–2
5. Validate — gauntlet stage 3
6. Filter — gauntlet stage 4
7. Blind challenge — gauntlet stage 5
8. Report & deliver — the workflow renders the report, persists all artifacts, and selects the delivery set deterministically (gauntlet stage 6); the session then posts that selection verbatim via post_review.py

Design properties of the pipeline:

• Deterministic transforms, no LLM JSON reconstruction. Every merge/filter/ranking decision is a pure function. The JS transforms are proven at parity against their retained Python twins by frozen golden fixtures; workflows/pipeline.js is a generated, dependency-free bundle that is byte-verified against a fresh build in CI.
• Trust boundaries at every hand-off. Verification results are accepted only with a valid receipt (nonce, head SHA, finding count); anything less degrades to a conservative unverified path — findings kept and labeled, never silently dropped, success never fabricated.
• Checkpointed and resumable. Each phase persists its output; an interrupted run resumes from the last completed phase.
• Failure-isolated. A failed agent nulls out without killing siblings; every stage records its gaps explicitly in the final report.

The rationale behind these choices — concern decomposition, blind challenge, context-pulling, hierarchical config, and the rest — is documented per-decision in docs/research/.

Project layout

claude-code-gauntlet/
├── .claude-plugin/            # Plugin + marketplace manifests
├── agents/                    # 13 named subagents: 7 discovery, change-summarizer,
│                              #   validator, challenger, executor, report-writer,
│                              #   artifact-writer
├── workflows/                 # Review pipeline: src/ (ESM modules), build.js (bundler),
│                              #   pipeline.js (generated bundle), test/ (node --test)
├── scripts/                   # Stdlib-only Python: verify_findings.py and
│                              #   post_review.py are invoked by the pipeline; the
│                              #   transform scripts are parity twins of the JS stages
├── tests/                     # pytest: scripts, JS/Python parity (frozen fixtures),
│                              #   bundle freshness
├── bench/                     # Benchmark harness: golden PRs, pinned judge, anchors,
│                              #   ledger, report generation
├── skills/
│   ├── code-gauntlet/         # Main orchestration skill + phase references
│   └── build-review-md/      # REVIEW.md configuration wizard
└── docs/research/             # Research artifacts informing the design

Development

python -m pytest tests/ -q            # pipeline scripts, JS/Python parity, bundle freshness
node --test workflows/test/*.test.js  # workflow pipeline: orchestration contracts, transforms
python -m pytest bench/tests -q       # benchmark harness

After editing anything in workflows/src/, rebuild the bundle (tests/test_bundle_fresh.py enforces that the committed bundle matches a fresh build byte-for-byte):

node workflows/build.js

Node 24 is a development-only dependency — the shipped bundle runs inside Claude Code's workflow runtime. All Python is standard-library only and language-agnostic: nothing assumes the language of the codebase under review.

License

Apache 2.0