# Collab Vs

> 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.

- Skill: `raine/collab-vs-3` (Agent Skill)
- Install (CLI): `npx skillmds@latest add raine/collab-vs-3`
- Raw SKILL.md: https://api.skillmd.com/api/skills/raine/collab-vs-3/raw
- Safety review: pending (external: skill-scanner PASS, skillspector PASS)
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: AI & ML
- Author: raine (https://skillmd.com/u/raine)
- Updated: 2026-09-22
- Page: https://skillmd.com/skills/raine/collab-vs-3

---


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:
   - Relevant files and their structure
   - Existing patterns and conventions
   - Dependencies and interfaces

2. **Make reasonable assumptions** - do NOT ask clarifying questions
   - Use best judgment based on codebase context
   - Prefer simpler solutions when ambiguous
   - Follow existing patterns in the codebase

3. **Prepare context summary** - create a brief summary of:
   - The task to be implemented
   - Relevant files discovered
   - Key patterns and conventions in the codebase
   - 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**:

````markdown
# [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`.