// The agent brainstorms with a partner LLM in alternating turns, building on each other's ideas. Synthesizes the best ideas into a plan.
| name | collab-vs |
| description | The agent brainstorms with a partner LLM in alternating turns, building on each other's ideas. Synthesizes the best ideas into a plan. |
Brainstorm collaboratively with a partner LLM, building on each other's ideas in alternating turns, then synthesize the best ideas into a plan.
Load the consult-llm skill before proceeding — it defines the invocation contract (stdin heredoc, flags, output format, multi-turn). Do not call the CLI without loading it first.
Selectors resolvable in this environment (depends on configured API keys):
!`consult-llm models`
Arguments: $ARGUMENTS
Check the arguments for flags:
Partner flag (exactly one required): any --<selector> from the Models block above (e.g. --gemini, --openai, --deepseek). Translates to -m <selector> for the CLI.
Strip all flags from arguments to get the task description.
Set variables from the partner flag:
MODEL: the selector (e.g. gemini, openai)PARTNER: the same selector, used as the display labelIf no --<selector> flag is provided, ask the user which partner to use,
listing the selectors from the Models block.
consult-llm SkillLoad it now. Follow its invocation contract for all CLI calls in this workflow.
Explore the codebase - use Glob, Grep, Read to understand:
Before planning or consulting, do enough research to understand how the requested behavior actually works. Before starting, think about what resources would be useful to obtain first: relevant source files, tests, logs, generated files, config, examples, command output, external docs, or authoritative upstream source. Gather the cheapest useful evidence before forming a plan.
Do not stop at the first plausible file, definition, setting, or example. Follow references, callers, related tests, and runtime usage until you can explain the current behavior and the likely impact of changing it.
Ground external semantics before planning - understand the requested behavior in the real system, not just this repo
Make evidence-backed assumptions - do NOT ask clarifying questions
Prepare context summary - create a brief summary of:
You kick off the brainstorm with initial ideas based on what you found in Phase 1. Write them out in full:
## Agent'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.
Alternate between the partner LLM and the agent. 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.
Step 1 — PARTNER responds to the agent's seed:
Invoke consult-llm per the consult-llm skill with -m <MODEL> and -f <path> for each relevant source file discovered in Phase 1. Send the build-on prompt below (with the agent's seed ideas embedded) per the consult-llm invocation contract.
Build-on prompt:
A collaborator shared these ideas:
[Agent'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 the returned thread_id as partner_thread_id (see consult-llm's multi-turn section).
Present PARTNER's response to the user as ## PARTNER's Ideas (Round 1).
Step 2 — agent responds to PARTNER:
Analyze the partner's response and build on it:
## Agent'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.
Continue alternating (PARTNER → agent). On each PARTNER turn, invoke consult-llm with -m <MODEL> and -t <partner_thread_id> to continue the conversation, sending the build-on prompt (with the agent's latest response embedded).
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.
After all rounds, synthesize the brainstorm into a plan:
Identify the strongest ideas — which approaches gained momentum across rounds?
Note convergence — where did you and the partner naturally align?
Pick the best combination — merge the strongest elements into one coherent approach. Be honest about where the partner's ideas won.
Write the plan:
# [Feature Name] Implementation Plan
**Goal:** [One sentence describing what this builds]
## Brainstorm Summary
**Key ideas from agent:** [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:
How to invoke the consult-llm CLI. Canonical reference for the invocation contract, flags, stdin/stdout format, and multi-turn. Load this before calling consult-llm from any workflow skill (/consult, /collab, /debate, /collab-vs, /debate-vs).
Coordinator skill that runs a multi-phase implementation across workmux worktrees. Each phase invokes /implement in its own worktree; the coordinator handles dispatch ordering (sequential, parallel, DAG), merge sequencing, and failure isolation. Composes /implement, /merge, workmux, and consult-llm.
Autonomously plan and implement a task with external LLM review. Writes a behavioral spec, runs an evidence-gated plan review (premortem + independent alternative), applies feedback through a decision ledger, implements with a triggered debug loop, and finishes with an evidence-gated post-implementation verification review. No user interaction.
Standalone multi-model code review of an existing diff. Multiple LLMs review in parallel; agent deduplicates, prioritizes by severity/confidence, and optionally applies localized fixes.
Multiple LLMs collaboratively brainstorm solutions, building on each other's ideas across rounds. Agent synthesizes the best ideas into a plan.
Consult an external LLM with the user's query.