oimiragieo 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.cjsoutput 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 analysisplan-generator— use debate output as an ADR input to plan-generatorsequential-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.