szarkans Wide ideas, several models
!"$CLAUDE_PLUGIN_ROOT/scripts/probe.sh" 2>/dev/null || "$HOME/.claude/skills/multi/scripts/probe.sh" 2>/dev/null || ./.claude/skills/multi/scripts/probe.sh
The first three answers a model gives are the answers a senior engineer gives in thirty seconds. Correct, forgettable. The interesting ones live past number three. Cognitive frames push one model out there; different model families start from different priors and land somewhere else again. This skill uses both axes at once and pays for one.
$SCRIPTS is whatever the probe printed as scripts-dir:.
If the line above reads Shell substitution failed instead of probe output,
the session is in a git worktree whose shell gate refused the header; the
plugin is fine. Run "$HOME/.claude/skills/multi/scripts/probe.sh" (or the
same under $CLAUDE_PLUGIN_ROOT) yourself, as one plain command, and read
scripts-dir: from that.
Pre-flight
If the user typed /multi:adhd or asked for it by name, go. They opted in.
Otherwise abort and answer directly unless all three hold: the question has several viable answers, the obvious answer being wrong is expensive, and the user did not say "quick", "just", "standard", "canonical" or "one-line".
Phase 1 — diverge (no critic)
Pick 5 frames from the table. Bias to code/design tags for code-shaped
problems, always keep one wild for range. Vary the picks between runs so the
same problem gives a different pool the second time.
Hand each frame to a different backend, rotating. With all three alive:
| frame | backend |
|---|---|
| 1 | Claude sub-agent |
| 2 | Codex |
| 3 | OpenCode |
| 4 | Claude sub-agent |
| 5 | Codex |
Start the external models first — they take 30–90 seconds and OpenCode spends most of a minute waking up. Launch the Claude agents while they run.
RUN="$($SCRIPTS/run-dir.sh --slug <two-to-four words: the project and the job, e.g. skills-fixing-multi>)"
$SCRIPTS/ask.sh --question-file "$RUN/adhd-f2.md" --out-prefix "$RUN/adhd-f2" \
--backend codex --effort medium &
$SCRIPTS/ask.sh --question-file "$RUN/adhd-f3.md" --out-prefix "$RUN/adhd-f3" \
--backend opencode &
wait
$RUN is this session's own directory, so two sessions brainstorming at once
do not overwrite each other. Shell variables do not survive between commands —
repeat that first line in every later block that uses $RUN, including the
frame files you write above.
One frame per file, one file per run. --backend exists precisely so the two
CLIs can get different questions in parallel instead of the same one.
Every branch — agent or CLI — gets only the problem, the user's context, its own frame, and this instruction:
You are in DIVERGENT mode. You are a generator, not a critic. Generate 6 short distinct ideas under this frame. Each idea is one phrase or one sentence. Do not evaluate. Do not rank. Do not hedge. The first three obvious answers everyone would give are banned. Push past them into the awkward middle. Output a JSON array only. No prose before or after.
[{"text": "...", "rationale": "..."}, ...]
For the CLIs add one line: "Do not read files or explore the repository"
unless the problem is genuinely about this codebase. Otherwise OpenCode spends
its run doing ls and git status before it starts thinking.
Isolation is the whole method. No branch sees another branch's output. Do not feed one frame's ideas into the next prompt, and do not write the branches out sequentially in your own context to save calls — that is one wider thought wearing five hats, not five branches.
When a backend is missing or dies
The probe says who is alive. A missing backend's frames go to Claude
sub-agents, and the report says so in one line: "Codex not installed — frames
2 and 5 ran as Claude agents." Never quietly re-label a Claude idea as
Codex's. Read the one-line text in ${RUN}/...-codex.txt.dead and
${RUN}/...-opencode.txt.dead for codex: ... / opencode: ... reasons;
those files explain missing/failed backends. codex: MISSING, opencode: NO OUTPUT, opencode: TIMEOUT
and an empty file are all "did not run" — check the file content, not just
that a file exists. Mention /multi:setup in the report when a backend is
missing — that's where they go to connect it.
Reading the CLI output
Codex writes the answer clean. OpenCode writes a terminal transcript: ANSI
escapes, a > build · <model> header, sometimes tool calls before the answer.
Run both through the parser rather than eyeballing them:
RUN="$($SCRIPTS/run-dir.sh)"
python3 $SCRIPTS/parse-branch.py "$RUN/adhd-f2-codex.txt" "$RUN/adhd-f3-opencode.txt" \
|| python $SCRIPTS/parse-branch.py "$RUN/adhd-f2-codex.txt" "$RUN/adhd-f3-opencode.txt"
The || python is not superstition: on Windows the name python3 resolves to
a Microsoft Store stub that prints "Python was not found" and exits 0, so the
first command can look like it succeeded while doing nothing.
It strips the escapes, takes the last valid [ ... ] block, and prints
NO FILE / EMPTY / NO JSON ARRAY for a branch that produced nothing. That
branch produced nothing — say so in the report, do not invent ideas for it.
Phase 2 — focus (critic on)
Score every idea 0–10 on novelty (distance from the default), viability (could it ship), fit (does it answer the stated problem). Flag traps — attractive but a hidden cost, false economy, premature abstraction — with a one-line reason.
Cluster by underlying angle, not surface keywords. Label clusters by the angle: "remove the file entirely" plays, "catch the drift" plays.
Deepen the top 3 by weighted score (novelty 0.35 + viability 0.40 + fit 0.25), traps excluded. Send them to different backends — one Claude agent, one Codex, one OpenCode — for the same reason Phase 1 splits:
You are in FOCUS mode. Take one promising idea and connect dots. Sketch how it would actually work in 4 to 8 sentences. Name the load-bearing risk. Name the first concrete step a coder would take. Then generate 3 to 5 sub-ideas that branch off. Output JSON only.
Frames
Pick 5.
| Frame | Vantage prompt | Tags |
|---|---|---|
| 3am on-call | You are woken at 3am when this breaks. What design would let you not get paged? | code, design |
| inversion | Ask the opposite question. Brainstorm how to guarantee NOT the goal, then negate each answer back. | code, design |
| remove the load-bearing assumption | Name the thing everyone treats as fixed — the file, the database, the request/response model — and imagine it gone. | code, design, wild |
| competitor trying to break it | You are a hostile insider. Exploit, corrupt or sabotage the obvious solution, then invert each attack into a design. | code, design |
| regulator | You audit for compliance and failure modes. What must be provable, traceable, or refusable here? | design |
| logistics | Steal mechanisms from logistics: queues, batching, just-in-time, hub-and-spoke, returns, last mile. | code, design |
| game design | Loops, rewards, friction, save-states, speedrun tricks. The user is a player. | design |
| extreme: no budget, one hour | No money, no team, one hour. The crudest version that still does the load-bearing thing. | code |
| biology | Transplant a mechanism — immune memory, apoptosis, epigenetics, DNA repair, differentiation — and force-fit it. | wild |
| speedrunner | Find glitches, skips, out-of-bounds tricks. What is the abusive-but-legal path? | code, wild |
| 10-year-old | You have never seen software. Describe naive but unencumbered approaches. Ignore convention. | wild |
Report
- Brief — one or two lines: the problem, any reframe used, and who ran.
- Wide set — the full pool grouped by cluster, each cluster labelled by
its angle. One short phrase per idea, with score chips
[N7 V8 F9]and the backend that produced it. - Converge — a 2–4 idea shortlist with why each is on it. Mark the non-obvious-but-viable pick with ★. Traps listed separately, one line each.
- Focus — the three deepened branches: sketch, load-bearing risk, first concrete step, child ideas.
- Provocation — one wildcard that opens a direction nobody took.
Then stop. Offer to push into one branch; do not start building any of them.
The confound, stated once
Frames are split across models, so a difference between two ideas is a difference of frame and of model at the same time. This is not a model comparison and must not be reported as one — never write "Codex thinks wider than DeepSeek" off this run. If the user actually wants families compared, that is the same frame sent to every backend, and it costs three times as much: offer it, do not silently do it.
Anti-patterns
- Convergence dressed as divergence. Ten variants of one idea is not breadth. If every candidate shares an assumption, you decorated, not diverged.
- Weirdness with no convergence. Thirty unsorted absurdities is as useless as one safe answer. Always converge and take a position.
- Refusing to commit. "Here are 20 ideas, you decide" is a cop-out.
- Faking a branch. A backend that returned nothing produced nothing. Say so.