# Adversarial Debate

> Run an Advocate/Critic/Judge debate over any decision with real tradeoffs. Use when the user asks whether to merge a PR, pick an architecture, hire a candidate, ship a feature, or make any judgment where both sides have valid points and a single-model answer would be too confident.

- Skill: `alex-jb/adversarial-debate` (Agent Skill)
- Install (CLI): `npx skillmds@latest add alex-jb/adversarial-debate`
- Raw SKILL.md: https://api.skillmd.com/api/skills/alex-jb/adversarial-debate/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: AI & ML
- Author: alex-jb (https://skillmd.com/u/alex-jb)
- Updated: 2026-09-17
- Page: https://skillmd.com/skills/alex-jb/adversarial-debate

---


# Adversarial Debate

Three-stage debate pattern for high-stakes decisions:

1. **Advocate** (Haiku) — strongest case FOR the proposal
2. **Critic** (Haiku) — strongest case AGAINST, rebutting the advocate
3. **Judge** (Sonnet) — synthesize and return a structured verdict

Cost ~$0.003 per debate. Takes ~10-15 seconds.

## When to use

**Good fits:**
- Should we merge this PR given tests, blast radius, author tenure?
- Postgres vs DynamoDB for this workload?
- Hire or pass after the last round?
- Ship this feature now or wait a week?
- Trading / investment: enter or stay out?
- Any decision with a defensible case on both sides

**Bad fits:**
- Questions with one right answer (use a regular call)
- Pure factual extraction (use a cheap single call)
- Open-ended brainstorming (debate narrows, not expands)
- Low-stakes decisions where $0.003 + 15s isn't worth it

## Usage

```python
from anthropic import Anthropic
from claude_debate import run_debate, DebateConfig

verdict = run_debate(
    proposal="Merge PR #42: adds Redis cache to auth middleware",
    client=Anthropic(),
    context={
        "diff_size": 340,
        "coverage": "85%",
        "author_tenure": "3 weeks",
        "prod_qps": 2400,
    },
    config=DebateConfig(
        decision_options=("APPROVE", "REQUEST_CHANGES", "DEFER"),
        criteria=["correctness", "rollback cost", "perf under load"],
    ),
)

print(verdict.decision)                    # "APPROVE"
print(verdict.confidence)                  # 72.0
print(verdict.reasoning_summary)           # one sentence
print(verdict.strongest_advocate_point)    # what was most convincing for
print(verdict.strongest_critic_point)      # what was most convincing against
```

## Design choices worth knowing

- **Critic sees the advocate's case** — so the critic's points are specific rebuttals, not independent arguments. This is what makes the debate adversarial instead of two parallel monologues.
- **Judge is explicitly asked for its tipping condition** — "what evidence would flip you?" — so the verdict is falsifiable, not just assertive.
- **`decision_options` are bounded** — the judge can't invent a new option. Forces a commit.
- **Confidence is calibrated in the prompt** — 80+ = would bet on it, 50 = genuinely uncertain. Not a vibe.
- **Cost asymmetry matches reasoning asymmetry** — advocate and critic are structured argument generation (Haiku is fine); judge is reasoning over conflicting evidence (Sonnet).

## Anti-patterns

- **Don't run debates on questions where one side is obviously right.** The advocate/critic will manufacture weak arguments and the verdict is noise.
- **Don't skip the `context` dict on non-trivial decisions.** Without facts, both sides speculate and the judge has nothing to weigh.
- **Don't treat the verdict as binding.** It's a structured second opinion — use it to pressure-test your own instinct, not replace it.