debate-vs

name: debate-vs
description: Claude debates an opponent LLM (Gemini or Codex) through multi-turn MCP conversation, then synthesizes the best approach and implements.

Debate an opponent LLM on the best implementation approach using multi-turn
conversations, then synthesize and implement.

Configuration

Arguments: $ARGUMENTS

Check the arguments for flags:

Opponent flags (mutually exclusive, exactly one required):

• --gemini → debate Gemini (model: "gemini")
• --codex → debate Codex (model: "openai")

Mode flags:

• --dry-run → debate and plan only, skip implementation
• --skip-final → skip the final review phase
• --rounds N → number of debate rounds (default: 1, max: 3). Each round =
  Claude argues + opponent responds.

Strip all flags from arguments to get the task description.

Set variables based on opponent flag:

• OPPONENT: "Gemini" or "Codex"
• MODEL: "gemini" or "openai"

If neither --gemini nor --codex is provided, ask the user which opponent to
use.

Phase 1: Understand the Task (No Questions)

1. Explore the codebase - use Glob, Grep, Read to understand:
2. Relevant files and their structure
3. Existing patterns and conventions

4. Dependencies and interfaces

5. Make reasonable assumptions - do NOT ask clarifying questions

6. Use best judgment based on codebase context
7. Prefer simpler solutions when ambiguous

8. Follow existing patterns in the codebase

9. Prepare context summary - create a brief summary of:

10. The task to be implemented
11. Relevant files discovered
12. Key patterns and conventions in the codebase
13. Any constraints or considerations

Phase 2: Opening Arguments

Both debaters propose their approach independently.

Step 1: Claude's Opening Argument

You ARE the debater. Form your own implementation approach based on what you
found in Phase 1. Write it out in full:

## Claude's Opening Argument

1. **Approach**: [2-3 sentences]
2. **Key decisions**: [architectural/design decisions]
3. **Files**: [files to create or modify]
4. **Steps**: [implementation steps]
5. **Trade-offs**: [pros and cons]

Present this to the user so they can see your position.

Step 2: Opponent's Opening Argument

Call mcp__consult-llm__consult_llm with:

• model: MODEL
• prompt: The opening argument prompt below
• files: Array of relevant source files discovered in Phase 1

Opening prompt:

I need to implement the following task:

[Task description]

Here's what I found in the codebase:
[Context summary - relevant files, patterns, conventions]

Propose your implementation approach:
1. **Approach**: Describe your recommended approach in 2-3 sentences
2. **Key decisions**: List the main architectural/design decisions
3. **Files**: What files to create or modify
4. **Steps**: High-level implementation steps
5. **Trade-offs**: What are the pros and cons of this approach?

Be specific and opinionated. Defend your choices.

Extract the thread_id from the response prefix [thread_id:xxx]. Store it
for subsequent rounds.

Present the opponent's opening argument to the user as
## OPPONENT's Opening Argument.

Phase 3: Debate Rounds

For each round (default 1, configurable with --rounds N):

Claude's Turn

Analyze the opponent's latest argument. Write your rebuttal:

## Claude's Rebuttal (Round N)

1. **Critique**: [weaknesses in opponent's approach]
2. **Defense**: [address weaknesses opponent identified in your approach]
3. **Concessions**: [good ideas from opponent worth adopting]
4. **Updated position**: [your refined recommendation]

Present this to the user.

Opponent's Turn

Call mcp__consult-llm__consult_llm with:

• model: MODEL
• thread_id: The thread_id from the previous response
• prompt: The rebuttal prompt below
• files: Array of relevant source files

Rebuttal prompt:

Your opponent (Claude) has responded with this rebuttal:

[Claude's rebuttal from above]

Provide your counter-argument:
1. **Critique**: What are the weaknesses in Claude's approach and rebuttal?
2. **Defense**: Address the weaknesses Claude identified in your approach
3. **Concessions**: Are there any good ideas from Claude worth adopting?
4. **Updated position**: State your refined recommendation

Be constructive but thorough in your critique.

Update the thread_id from the response prefix if a new one is returned.

Present the opponent's rebuttal to the user as
## OPPONENT's Rebuttal (Round N).

Phase 4: Synthesis and Plan

As both debater and moderator, synthesize the final approach:

1. Score the arguments:
2. Which approach is simpler?
3. Which approach better fits existing patterns?
4. Which critiques were valid?

5. What concessions were made?

6. Identify consensus: Where did you and the opponent agree?

7. Resolve disagreements: For each point of contention:

8. Evaluate the arguments from both sides
9. Be honest about where the opponent had the stronger argument

10. Prefer simpler solutions when arguments are equally strong

11. Write the verdict as part of the plan:

# [Feature Name] Implementation Plan

**Goal:** [One sentence describing what this builds]

## Debate Summary

**Claude's position:** [1-2 sentence summary] **OPPONENT's position:** [1-2
sentence summary]

**Points of agreement:**

- [Consensus point 1]
- [Consensus point 2]

**Resolved disagreements:**

- [Issue]: Claude said X, OPPONENT said Y → **Verdict:** [Decision and why]

**Verdict:** [2-3 sentences on the final synthesized approach]

---

### Task 1: [Short description]

**Files:**

- Create: `exact/path/to/file.py`
- Modify: `exact/path/to/existing.py` (lines 123-145)

**Steps:**

1. [Specific action]
2. [Specific action]

**Code:**

```language
// Include actual code, not placeholders
```

---

Guidelines:

• Exact file paths - never "somewhere in src/"
• Complete code - show the actual code
• Small tasks - 2-5 minutes of work each
• DRY, YAGNI - only what's needed
• Be honest - credit the opponent when its ideas won

Save the plan to history/plan-<feature-name>.md.

Phase 5: Implement

If --dry-run: Skip to Phase 7 (Summary) - report the debate and plan
without implementing.

Implement the plan without further interaction:

1. Follow the plan exactly - implement each task in order
2. Commit after each logical unit - keep commits small and focused
3. If something is unclear - make a reasonable decision and note it in the
   commit message
4. If a task fails - attempt to fix it before moving on
5. Only stop if there's a blocking error that cannot be resolved

Implementation rules:

• Work through tasks sequentially
• Test changes when possible
• Keep commits atomic and well-documented
• Use commit messages that explain the "why"

Phase 6: Final Review

If --skip-final: Skip to Phase 7 (Summary).

After implementation, have the opponent review using the existing thread (full
debate context):

Call mcp__consult-llm__consult_llm with:

• model: MODEL
• thread_id: The thread_id from the debate
• prompt: Final review prompt below
• git_diff: { "files": [list of changed files], "base_ref": "HEAD~N" }

Final review prompt:

The implementation is complete. Review the changes:
- Any bugs or edge cases missed?
- Does the implementation match what we agreed on during the debate?
- Code quality issues?
- Security concerns?

Be concise. Only flag issues worth fixing.

Apply fixes if the opponent identifies clearly valid concerns:

• Fix bugs and edge cases
• Commit each fix separately with clear messages

Skip minor style suggestions.

Phase 7: Summary

Present a final summary to the user:

## Summary

**Implemented:** [One sentence describing what was built]

**Debate outcome (Claude vs OPPONENT):**
- Claude advocated: [key position]
- OPPONENT advocated: [key position]
- Final verdict: [who won which points, synthesized approach]

**Key decisions from debate:**
- [Decision 1 - who proposed it and why it won]
- [Decision 2 - who proposed it and why it won]

**Post-implementation fixes:**
- [Fix applied after final review, if any]

**Commits:**
- `abc1234` - [commit message]
- `def5678` - [commit message]