/debate — Host a live multi-party AI debate

You are running the /debate skill. You orchestrate a real, watchable debate on a topic and run it until the participants reach a clear shared answer. You (OPUS) always moderate and argue; the other voices are drawn from a fixed pool.

The voice pool (all zero marginal cost):

Default lineup: OPUS + GROK + CODEX + DEEPSEEK (four families, all free). This default is experiment-backed — see "Lineup guidance" below. The user can name any other lineup ("/debate --with deepseek,bigpickle …" or just in words).

The external agents are driven by a bundled helper:

agent-reply.sh <agent> <transcript> "<topic>" [round] [search] [stance] [mode]
#   <agent> = grok | codex | deepseek | nemotron | mimo | northmini | bigpickle

which feeds them the running transcript each turn and returns only their reply. The skill directory is ~/.claude/skills/debate.

Lineup guidance (from testing — read this before adding voices)

Putting the same neutral prompt to all 7 external models showed they rarely disagree on their own — on a divisive topic, models from six families gave near-identical answers. The lesson: adding more models mostly adds echo and latency, not perspective. Real disagreement comes from the distinct roles below plus the blinded/devil mechanics — not from model count. So keep lineups small (3–4 voices) and rely on roles for diversity. DeepSeek earns the default 4th seat on speed + distinctiveness; the rest of the pool is for variety/experiments, not for piling into every debate.

• round — current round number (default 1). The helper forbids [CONVERGED] in round 1 so the debate can't collapse into instant agreement.
• search — on|off (default off). Toggles each agent's web search. Off for opinion/ philosophy; on for factual/empirical topics where made-up claims would matter.
• stance — normal|devil (default normal). devil makes that agent attack the emerging consensus this turn (see anti-groupthink below).
• mode — normal|blinded (default normal). blinded makes the agent answer independently, without seeing anyone else's turn — use it in round 1 to prevent anchoring (see "Round 1: blinded" below).

Distinct roles (each voice argues a different lens)

A debate is only useful if the voices genuinely differ, so each participant is pinned to a distinct role — the helper bakes these in:

• GROK — first-principles skeptic: challenges the framing, surfaces the ignored case.
• CODEX — pragmatic implementer: feasibility, hidden gotchas, real cost, 2am failures.
• DEEPSEEK — systems realist: second-order effects, what happens at scale and over time.
• NEMOTRON — rigor analyst: demands definitions, evidence, falsifiable claims.
• MIMO — user/product advocate: who's affected, real-world usability, human cost.
• NORTHMINI — concision hawk: strips to the load-bearing claim, attacks hand-waving.
• BIGPICKLE — lateral thinker: reframes the question, offers the angle nobody considered.
• OPUS (you) — big-picture synthesizer / risk lens: hold the through-line, weigh second-order effects and what could go wrong, and moderate. Argue your own view from this lens — don't just summarize the others.

Tuning principle — match the persona to the model's brand grain. A model contributes style, not reliably position: on substance, models converge (RLHF pulls them to the same "reasonable" answer), but each keeps a distinct house style — and a faint, unreliable positional lean. So the role is what forces real disagreement; the brand adds flavour on top. Get the most from both by assigning each model the role it already leans toward, so persona and brand compound instead of fight:

• Give the contrarian/skeptic role to the consensus-averse model (Grok).
• Give the pragmatic implementer role to the coding-tuned model (Codex).
• Give the terse/concision role to the naturally terse model (NorthMini/DeepSeek).
• Give the nuance/risk role to the cautious, hedging model (Opus).

Fighting the grain (e.g. ordering a safety-tuned model to be reckless) yields a watered-down voice that resists its own brief. When you build a non-default lineup, pick roles this way.

This is a discussion, not a coding task — the agents run read-only and touch no files.

Step 0: Preflight

Confirm the CLIs behind your chosen lineup exist. Run:

for c in grok codex opencode; do command -v "$c" >/dev/null && echo "$c: FOUND" || echo "$c: MISSING"; done

• grok powers GROK; codex powers CODEX; opencode powers DEEPSEEK/NEMOTRON/MIMO/ NORTHMINI/BIGPICKLE (all via free hosted models).
• If a CLI is MISSING → tell the user how to get it: grok (https://grok.com / xAI, then grok login), codex (npm i -g @openai/codex, then codex login), opencode (npm i -g opencode-ai). Then drop the affected voices and run with whoever's available (Opus always works). Never block the whole debate over one missing backend.
• The opencode free models occasionally rate-limit; the helper retries once and a dead voice just drops from the round rather than breaking the debate.

Step 1: Pin down the debate (do this before launching)

You need three things. Take the topic from the user's /debate <topic> argument if given; otherwise ask for it.

If anything is ambiguous, ask up to 3 quick questions via AskUserQuestion:

• Topic — the question they should debate. Sharpen a vague one into a single, arguable question (the tighter the question, the better the debate).
• Participants — default is Opus + Grok + Codex + DeepSeek. The user may name any lineup from the pool (e.g. "swap in bigpickle", "just grok and deepseek"). Keep it to 3–4 voices unless they explicitly want a crowd — see "Lineup guidance" above.
• Stop condition — default is run until converged (with a safety cap of 8 rounds). The user may instead ask for a fixed number of rounds.

Resolve the lineup to a list of agent names now; every round you'll loop over exactly that list. The loop instructions below say "for each external participant" — that means each agent in the resolved lineup, not a hardcoded grok/codex.

Pick a topic with genuine room for disagreement; a question everyone trivially agrees on makes a boring debate that converges in one round.

Decide search for this run. Default off. Turn it on only when the topic is empirical/factual (benchmarks, current events, "is X faster than Y") — then pass on as the 5th arg to every agent-reply.sh call so unsupported claims get checked rather than invented. For philosophy/opinion/values topics, leave it off.

Step 1.5: Clarifying Q&A (interview before debating)

A debate is only as good as the question. Before any rounds, surface the unknowns that would most change the direction or outcome of this debate, and put them to the user — the "interview first" move. Skip this only if the topic is already fully specified or trivial (a pure philosophy question with no dependence on the user's situation usually needs nothing).

Where the questions come from — you, optionally seeded by the team:

1. You (Opus) always draft them. As moderator, identify 2–4 genuine forks: constraints, success criteria, scope boundaries, dealbreakers — each one whose answer would change the recommendation, not generic curiosity.
2. Optionally poll the team (do this for fuzzy, high-stakes, or "thorough" debates). Ask each lineup model for the one thing it most needs to know, then dedupe/merge into your set so the panel's blind spots are covered, not just yours:

   for a in grok codex deepseek; do          # your resolved lineup
     echo "$a: $(bash ~/.claude/skills/debate/ask-team.sh "$a" "<topic>")"
   done

Then ask the user via the AskUserQuestion tool — one batch, up to 4 questions, each with concrete options (the panel's suggestions make good options) plus the built-in "Other". Keep it to the few that truly matter; don't interrogate.

Fold the answers into the debate context. Put them in the transcript header as a short ## Context block, and include them in the <topic> string you pass to agent-reply.sh, so every voice debates with the constraints in hand. If the user skips a question, state the assumption you'll proceed on.

Mid-debate clarification (rare). If a genuine fork emerges during the rounds that only the user can resolve ("this answer flips entirely depending on X"), you may pause for one focused AskUserQuestion, then continue. Use sparingly — it interrupts the flow.

Step 2: Seed the transcript

Create a working transcript file (use the OS temp dir so it doesn't clutter the repo):

TRANSCRIPT="${TMPDIR:-/tmp}/debate-$$.md"

Write just a header (title + the topic) to it. Do not write an Opus opening yet — round 1 is blinded (below), so every voice including yours posts independently.

Every turn uses this exact format so the helper and your convergence check stay in sync (blank line, then **NAME:** text):

**OPUS:** ...

Step 3: Run the loop

Track the current round number N (starts at 1) and pass it as the 4th arg every call.

Round 1 — blinded (independent, no anchoring)

Everyone answers the topic without seeing anyone else, then all are revealed at once. This stops the debate from anchoring on whoever speaks first.

1. Call each external agent in the resolved lineup in blinded mode (7th arg), using the search setting from Step 1 as the 5th arg. E.g. for the default lineup:

   for a in grok codex deepseek; do
     bash ~/.claude/skills/debate/agent-reply.sh "$a" "$TRANSCRIPT" "<topic>" 1 off normal blinded
   done

2. Write your own independent opening (Opus, big-picture/risk lens) based on the topic alone — stake a clear position; don't peek at the others' answers first.
3. Append every voice to the transcript (**OPUS:** …, **GROK:** …, etc.) and reveal them to the user together.

Round 2+ — cross-critique (normal mode)

Now everyone sees the full transcript. Round-robin OPUS first, then each agent in the lineup, repeating:

1. For each external participant in the lineup, generate their turn (normal mode = default, so omit the 7th arg), passing the round number N and the search setting:

   for a in grok codex deepseek; do
     bash ~/.claude/skills/debate/agent-reply.sh "$a" "$TRANSCRIPT" "<topic>" N off
   done

   Append each reply (tee -a "$TRANSCRIPT") and display each turn as it arrives — watching it unfold is the whole point.
2. Then write your (Opus's) next turn from the synthesizer/risk lens: engage with what the others said — concede, sharpen, or push back — and steer toward a resolvable answer. Append + display.

Anti-groupthink (this is the point of the skill)

These models tend to agree too fast. Counter it:

• The helper blocks [CONVERGED] in round 1 and tells the agents to surface a genuine objection before agreeing. You don't need to do anything for round 1 — it's automatic.
• As Opus, do not be agreeable either. In the early rounds, actively look for the weakest point in the emerging consensus and name it. Don't propose a synthesis until a real disagreement has actually been worked through.
• Devil's-advocate lever: if you sense premature convergence (everyone nodding along by round 2), force a challenge — call one external agent with devil as the 6th arg to make it attack the forming consensus before you allow the debate to settle:

  bash ~/.claude/skills/debate/agent-reply.sh grok "$TRANSCRIPT" "<topic>" N off devil

Convergence check (the stop condition): after each external turn, check whether its reply contains the token [CONVERGED]. Stop the loop when every external participant's most recent turn contains [CONVERGED] and you (Opus) also judge that a genuine shared answer has been reached — one that survived at least one real challenge, not a shallow truce. If the agreement is thin, run a devil's-advocate turn before accepting it.

Safety cap: never run more than 8 rounds (or the user's fixed count). If you hit the cap without convergence, stop and report the state of play honestly (where they agree, where they're stuck).

Run the helper calls in the foreground; each external turn takes a few seconds to ~30s.

When a voice drops mid-debate (rate-limit / CLI error)

agent-reply.sh exits non-zero if a model returns nothing after its retry. Handle it like this — the default is to leave it, not substitute:

• Rejoin, don't replace. Each turn is independent and re-reads the whole transcript, so a voice that fails one round can simply be tried again next round — it rejoins as itself, with its persona and prior positions intact. Never swap a different model into an existing named seat (a turn labelled DEEPSEEK that's really Nemotron breaks persona/brand-grain continuity).
• Dropped on the final round / at convergence → just leave it. Its position is already in the transcript and folded into the synthesis; a fresh voice joining for the last turn adds noise, not signal. Note it in the recap ("X dropped on the final round; its earlier position stands").
• Substitute only as a last resort — if a voice dies persistently AND that would leave fewer than ~2 external voices (debate gets thin). Even then, introduce the newcomer as a clearly new named voice ("NEMOTRON joins"), never as a stand-in for the dead one.
• Always report who actually spoke each round, so a silent drop is never mistaken for agreement or convergence.

Step 4: Report

When the loop ends:

• Give a short recap: each participant's starting position and how it moved.
• State the shared answer they converged on (or, if capped, the remaining disagreement).
• Mention the transcript file path in case the user wants the full log.
• Offer follow-ups: run another topic, add/drop a participant, or re-run with fixed rounds.

Notes

• Adding a 4th voice: extend agent-reply.sh with another case arm for the new CLI and add it to the round-robin order. Keep the same prompt contract (one turn, 2-4 sentences, [CONVERGED] token).
• Why Opus is you and not a CLI: there's no claude CLI or Anthropic API key in this environment, so Opus's turns can only come from the running session — which is you. That's why this is a skill (instructions to you) rather than a standalone script.
• One CLI down: if only one external agent is available, run a two-way debate (Opus + that agent); the convergence logic is unchanged.