Adhd

---
name: adhd
description: >-
  Divergent ideation across model families — the same brainstorm, but each
  cognitive frame is handed to a different model (Claude sub-agent, OpenAI
  Codex, a cheap third via OpenCode) so the ideas diverge by frame and by
  model priors at once. Use for open design questions, architecture and API
  shape, naming, schema choices, fuzzy bugs with no known root cause, or on
  "multi adhd", "brainstorm with everyone", "wide ideas from all models".
  Skip for lookups, syntax, and anything phrased as "quick", "standard" or
  "canonical".
allowed-tools: Bash, Read, Grep, Glob, Agent
argument-hint: "[the problem to think wide about]"
metadata:
  based-on: "ADHD by UditAkhourii — https://github.com/UditAkhourii/adhd (MIT)"
---

# Wide ideas, several models

!`sh -c 'for p in "$CLAUDE_PLUGIN_ROOT/scripts" "$HOME/.claude/skills/multi/scripts" "./.claude/skills/multi/scripts"; do [ -x "$p/probe.sh" ] && { "$p/probe.sh"; echo "scripts-dir: $p"; exit 0; }; done; echo "probe: NOT FOUND — locate scripts/probe.sh in this plugin and run it yourself"'`

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

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

```bash
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:<model from probe>" --fallback <fallback model from probe> &
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:

```bash
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)

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

2. **Cluster** by underlying angle, not surface keywords. Label clusters by the
   angle: "remove the file entirely" plays, "catch the drift" plays.

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

1. **Brief** — one or two lines: the problem, any reframe used, and who ran.
2. **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.
3. **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.
4. **Focus** — the three deepened branches: sketch, load-bearing risk, first
   concrete step, child ideas.
5. **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.