Adversarial Debate Skill

Adversarial Debate

Overview

Runs a structured N-round debate between two opposing agents (pro and con) on any decision-requiring topic, then synthesizes a moderator recommendation. Built for architectural decisions, technology choices, security trade-offs, and design reviews — anywhere strong opinions exist and the right answer is non-obvious.

When to Use

Architecture decision records (ADRs) needing structured justification
Technology selection (e.g., Redis vs Postgres, REST vs GraphQL)
Security trade-off analysis (e.g., strict vs permissive auth policy)
Design review of competing approaches
Any HIGH/EPIC task where the planner identifies genuine disagreement among specialists

Do not use for:

Settled best practices (where there is consensus)
Simple implementation tasks
Decisions already made and documented in ADRs

Iron Law

NO RECOMMENDATION WITHOUT CITED DEBATE EVIDENCE

The moderator's synthesis MUST reference specific arguments made during rounds. A recommendation that ignores debate content is invalid.

Debate Protocol

Pre-Debate: Stance Assignment

Before any rounds begin, the invoking agent MUST define:

Topic — one clear decision question (not open-ended)
Pro stance — what the PRO agent advocates for
Con stance — what the CON agent argues against / alternative
Number of rounds — default 3, max 5
Success criteria — what a good recommendation looks like

Example:

Topic: Should we use event sourcing for the order service?
Pro stance: Yes — event sourcing provides audit trail and temporal queries
Con stance: No — event sourcing adds complexity; CRUD with snapshots is sufficient
Rounds: 3

Round Structure

Each round follows this fixed sequence:

Step 1: PRO Argument

PRO agent argues its stance with:
- 1 primary argument (specific, concrete)
- 1 supporting piece of evidence (metric, case study, or first-principles reasoning)
- 1 anticipated objection pre-addressed

Step 2: CON Rebuttal

CON agent responds with:
- Direct refutation of PRO's primary argument (must engage it — no deflection)
- 1 counter-argument from CON's stance
- 1 counter-evidence or challenge to PRO's evidence

Step 3: Round Score

Score each round immediately using this rubric (0–10 per dimension):

| Dimension | Description | | ---------------- | ----------------------------------------------------- | | Specificity | Arguments use concrete examples, not vague claims | | Evidence | Claims backed by data, precedent, or first principles | | Rebuttal Quality | Directly addresses opposing argument, no deflection | | Relevance | Arguments stay on the stated topic |

Round Score = mean(Specificity, Evidence, Rebuttal Quality, Relevance)

Track cumulative scores per agent across rounds.

Final Synthesis (Moderator)

After all rounds, the moderator agent produces a structured synthesis:

## Debate Summary

**Topic:** [restate topic]
**Rounds completed:** N
**PRO total score:** X.X/10
**CON total score:** X.X/10

## Key Arguments

**Strongest PRO argument:** [cite round + argument]
**Strongest CON argument:** [cite round + argument]

## Decision Factors

List 3-5 factors that should determine which stance wins in context:

1. Factor: [e.g., team expertise] → Favors: [PRO/CON/neutral]
2. ...

## Recommendation

**Decision:** [clear recommendation — not "it depends"]
**Confidence:** [High / Medium / Low]
**Rationale:** [2-3 sentences citing specific debate evidence from rounds]

## Conditions / Caveats

[Any conditions under which the recommendation should be revisited]

Workflow

Step 0: Load Context and Memory

# Check for prior debate results on same topic
grep -r "adversarial-debate" C:/dev/projects/agent-studio/.claude/context/memory/decisions.md 2>/dev/null | tail -5

Check .claude/context/memory/decisions.md for prior ADRs on same topic. If a prior debate exists, acknowledge it and note whether conditions have changed.

Step 1: Parse and Validate Input

Validate input against schemas/input.schema.json:

node .claude/skills/adversarial-debate/hooks/pre-execute.cjs '{"topic":"...","proStance":"...","conStance":"...","rounds":3}'

Expected output: { "valid": true } or error listing missing fields.

Step 2: Run Debate Rounds

For each round 1..N:

PRO agent produces its argument (following Round Structure above)
CON agent produces rebuttal (must reference PRO's specific argument)
Score the round using the rubric — output a score table
Record round to scripts/main.cjs output buffer

Step 3: Moderator Synthesis

After all rounds, produce the Final Synthesis following the template in templates/implementation-template.md.

The moderator MUST:

Reference at least 2 specific round arguments by round number
State a single clear recommendation (not "it depends without conditions")
Assign a confidence level (High/Medium/Low) with justification

Step 4: Persist Decision

Append result to .claude/context/memory/decisions.md:

echo "## [$(date +%Y-%m-%d)] Adversarial Debate: {TOPIC}
- Recommendation: {DECISION}
- Confidence: {CONFIDENCE}
- Rounds: {N}
- Cite: {KEY_EVIDENCE_SUMMARY}" >> .claude/context/memory/decisions.md

Step 5: Emit Observability Event

const { sendEvent } = require('.claude/tools/observability/send-event.cjs');
sendEvent({
  tool_name: 'adversarial-debate',
  agent_id: process.env.AGENT_ID || 'unknown',
  session_id: process.env.SESSION_ID || 'unknown',
  outcome: 'success',
});

Enforcement Hooks

Input validated against schemas/input.schema.json before execution. Output contract defined in schemas/output.schema.json.

Pre-execution hook: hooks/pre-execute.cjs — validates topic, stances, rounds range (1-5). Post-execution hook: hooks/post-execute.cjs — emits observability event via send-event.cjs.

Anti-Patterns

Never let agents pick their own stances — stance drift produces muddled debates
Never skip round scoring — unscored debates allow moderator bias in synthesis
Never produce "it depends" recommendations without explicit conditions listed
Never use more than 5 rounds — beyond round 3, new arguments rarely emerge
Never invoke debate for trivial decisions — overhead not justified for settled questions

Related Skills

llm-council — parallel multi-LLM synthesis (complementary: debate is sequential, council is parallel)
advanced-elicitation — meta-cognitive reasoning for single-agent analysis
plan-generator — use debate output as an ADR input to plan-generator
sequential-thinking — structured problem decomposition for the topic before debate

Memory Protocol

Before starting: Read .claude/context/memory/decisions.md for prior ADRs on related topics.

After completing: Append structured summary to .claude/context/memory/decisions.md with date, topic, recommendation, confidence, and key evidence citations.

Do not write directly to patterns.json, gotchas.json, or open-findings.json — use MemoryRecord tool.

Agent Skills: Adversarial Debate

Install this agent skill to your local

Skill Files