collab-vs

name: collab-vs
description: Claude brainstorms with an opponent LLM (Gemini or Codex) in alternating turns, building on each other's ideas. Synthesizes the best ideas into a plan.

Brainstorm collaboratively with an opponent LLM, building on each other's ideas in alternating turns, then synthesize the best ideas into a plan.

Arguments: $ARGUMENTS

Check the arguments for flags:

Partner flags (mutually exclusive, exactly one required):

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

Strip all flags from arguments to get the task description.

Set variables based on partner flag:

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

If neither --gemini nor --codex is provided, ask the user which partner 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: Seed (Claude starts)

You kick off the brainstorm with initial ideas based on what you found in
Phase 1. Write them out in full:

## Claude's Ideas

1. **Ideas**: [2-3 possible approaches with brief descriptions]
2. **Favorite**: [which approach you lean toward and why]
3. **Open questions**: [aspects you're unsure about or would benefit from another perspective]
4. **Risks**: [what could go wrong or be tricky]

Present this to the user.

Phase 3: Back and Forth

Alternate between the partner LLM and Claude. Each turn builds on the previous
response. Continue until the ideas converge into a clear approach — typically
2-3 rounds, but use as many as needed.

Round 1

Step 1 — PARTNER responds to Claude's seed:

Call mcp__consult-llm__consult_llm with:
- model: MODEL
- prompt: Build-on prompt below, with Claude's seed ideas
- files: Array of relevant source files discovered in Phase 1

Build-on prompt:

A collaborator shared these ideas:

[Claude's ideas from above]

Build on their thinking:
1. **What resonates**: Which ideas are strong? Why?
2. **Combinations**: Can any ideas be combined into something better?
3. **New ideas**: Did their thinking spark any new approaches?
4. **Refinements**: How would you improve the most promising ideas so far?
5. **Concerns resolved**: Did their ideas address any open questions?

Keep building — don't tear down. Refine toward the best solution.

Save partner_thread_id from the [thread_id:xxx] prefix.

Present PARTNER's response to the user as ## PARTNER's Ideas (Round 1).

Step 2 — Claude responds to PARTNER:

Analyze the partner's response and build on it:

## Claude's Ideas (Round 1)

1. **What resonates**: [which of PARTNER's ideas are strong and why]
2. **Combinations**: [ideas that can be merged into something better]
3. **New ideas**: [anything their thinking sparked]
4. **Refinements**: [improvements to the most promising ideas so far]
5. **Concerns resolved**: [open questions addressed]

Present this to the user.

Subsequent rounds

Continue alternating (PARTNER → Claude), always passing the previous response
to the partner via the build-on prompt and using thread_id to maintain
context.

When to stop: Both sides are refining details rather than introducing new
ideas, and a clear approach has emerged. Don't stop while there are still
unresolved open questions or competing directions.

Phase 4: Synthesize

After all rounds, synthesize the brainstorm into a plan:

1. Identify the strongest ideas — which approaches gained momentum across
   rounds?

2. Note convergence — where did you and the partner naturally align?

3. Pick the best combination — merge the strongest elements into one
   coherent approach. Be honest about where the partner's ideas won.

4. Write the plan:

# [Feature Name] Implementation Plan

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

## Brainstorm Summary

**Key ideas from Claude:** [2-3 bullet points]
**Key ideas from PARTNER:** [2-3 bullet points]
**Convergence:** [Where they naturally agreed]
**Synthesis:** [How the final approach combines the best of both]

---

### 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 partner when its ideas were better

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