ADHD

Stop picking the textbook answer. The first three answers the model would give are the answers a senior engineer would give in thirty seconds. Correct. Forgettable. The interesting answers live past number three, in the awkward middle nobody walks into. This skill makes the model walk there.

Onboarding — start here

1. What you actually get

Not a longer answer. A wider one, then a verdict. The skill fans out ~5 isolated agents, each thinking under a different cognitive frame (a regulator, a biologist, a speedrunner, a 10-year-old, someone with $0 and one hour), pools what they produce, scores it, kills the traps, and deepens the best three into buildable sketches. It ends with a shortlist and an opinion — not a menu.

2. How to invoke it

/adhd how should we structure the lead-scoring model?

Typing /adhd is an explicit opt-in: the skill skips its own cost gate and runs. You can also just say "ADHD mode", "use the adhd skill on this", or "brainstorm this properly" — those trigger it too, but the self-judge in Pre-flight may still abort if the question turns out to have one canonical answer.

Give it the problem plus any hard constraints in the same message. Constraints sharpen divergence rather than limiting it — "must run inside Clay", "no new vendors", "ships this week" all make the output more usable.

3. When it is worth the money

It costs about 10 agent calls and 30–90 seconds, roughly 5–10x a normal answer. Spend it where being merely correct is not good enough:

In this workspace specifically: most GTM work is recombination of known plays — just build those. Reach for this when there is no existing play to copy.

4. Reading the output

It comes back in five fixed blocks — see Output shape. Read them in this order:

1. Converge first. That is the shortlist and the opinion. The ★ marks the non-obvious-but-viable pick, which is usually the reason you ran this.
2. Traps next. Each is an idea that looks good with a one-line reason it is not. Often the most valuable part.
3. Focus if a shortlist item interests you — sketch, load-bearing risk, first concrete step.
4. Wide set only if nothing landed. Score chips read [N7 V8 F9] = novelty, viability, fit, each 0–10.
5. Provocation is the escape hatch: one wildcard to push into on a re-run.

5. Steering a re-run

Frame picks vary between runs, so re-running the same problem gives a different candidate set — that is by design, not a bug. To steer it, name what you want: "re-run with the adversarial and 3am on-call frames", "go weirder", "everything came back too expensive, constrain to $0". Frames are listed in Frames.

6. It composes

For a fully open problem, chain: `adhd` to widen the option space → `neuroarxiv` to check whether the promising ones are already solved and how → `advise-project-approach` to pick the build path.

Pre-flight (run before Phase 1)

This skill is expensive. About 10 Agent calls, 30 to 90 seconds wall clock, 5 to 10x a single answer. Do not pay that cost when a direct answer is better. Run this gate before Phase 1.

Step 1. Explicit invocation check.

If the user typed /adhd or explicitly asked for ADHD mode, "use the adhd skill", or "run ADHD on this", SKIP the rest of this section and go straight to Phase 1. The user opted in. Do not second-guess.

Step 2. Self-judge (only if Step 1 did not match).

Ask yourself three questions. If the answer to any is no, ABORT.

1. Open-ended? Would a senior engineer give multiple viable answers here, or is there one canonical answer? If canonical, abort.
2. High-stakes? Is the cost of the obvious answer being wrong actually high? Architecture decisions, public API surfaces, naming a real product, fuzzy bugs with no known root cause, schema design = yes. Side project at 11pm = no.
3. Open phrasing? Did the user avoid words like "quick", "standard", "canonical", "textbook", "just", "one-line"? If they used any of those, they want the direct answer. Abort.

If all three checks pass, proceed to Phase 1.

If any fails, ABORT and answer the question directly. Optionally append one sentence: "If you want a wider exploration under parallel cognitive frames with explicit trap detection, run `/adhd <your problem>`."

The loop

Two strict phases. Mixing them kills idea quality, because the critic strangles the generator.

Phase 1 — Diverge (no critic)

For the problem P:

1. Pick 5 cognitive frames from the table below. Bias toward engineering tags when the problem is code-shaped. Always include at least one wild frame to keep range.

1. Spawn 5 parallel Agent/Task tool calls. One per frame. Each Agent gets only:
   • the problem P
   • any context the user provided
   • the chosen frame's vantage prompt
   • a system instruction that forbids evaluation

The exact instruction to give each Agent:

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": "..."}, ...]

1. Critical invariant. The Agent calls must be parallel and isolated. Do NOT serialize them. Do NOT pass one branch's output as context to another. Branches that see each other anchor each other and the whole method collapses to a wider single thought.

Phase 2 — Focus (critic on)

After all branches return:

1. Score. Rate each idea on three axes 0 to 10: novelty (distance from the obvious default), viability (could it actually ship), fit (does it address the stated problem). For any idea that looks attractive but is a trap (hidden cost, false economy, will not scale, premature abstraction), flag it with a one-line reason.

1. Cluster. Group ideas into 3 to 6 clusters by their underlying angle, not by surface keywords. Label clusters by angle: "remove the server plays", "cache-shaped plays", "batched-window plays", "race-multiple- backends plays".

1. Deepen the top 3. Rank by weighted score (novelty 0.35 + viability 0.40 + fit 0.25), exclude traps, take top 3. For each, spawn one Agent call that produces:
   • a 4 to 8 sentence sketch of how the idea works
   • the load-bearing risk
   • the first concrete step a builder would take
   • 3 to 5 child ideas (variations, hybrids, unlocks)

Deepen Agent instruction:

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 (variations, combinations with other domains, things this unlocks). Output JSON only.

Frames

Pick 5 per run.

Picking frames

For code-shaped problems: pick 4 frames tagged code or design, plus 1 tagged wild. For open product or strategy problems: a mix from all tags. Vary the picks across sessions so the same problem produces different candidate sets when re-run.

Output shape

After Phase 2, render in this order. Do not collapse it into a wall of prose. The structure is the point.

1. Brief. One or two lines confirming the problem and any reframe used.
2. Wide set. Full pool grouped by cluster. Each cluster labeled by underlying angle. Each idea is one short phrase. Show score chips like [N7 V8 F9] next to each.
3. Converge. A 2 to 4 idea shortlist. State why each is on the list. Mark the non-obvious-but-viable pick explicitly with ★. List traps separately, each with the one-line reason it is a trap.
4. Focus. The 3 deepened branches. For each: the sketch, the load- bearing risk, the first concrete step, and the child ideas.
5. Provocation. One wildcard question or idea that opens a new direction the user can push into if nothing landed.

Anti-patterns

These are how this skill goes wrong. Watch for them.

• Convergence disguised as divergence. Ten minor variations of one idea is not breadth. If every candidate shares the same underlying assumption, you have not diverged. You have decorated.
• Weird-for-weird's-sake with no convergence. A pile of 30 unsorted absurdities is as useless as one safe answer. Always converge.
• Walls of equally-weighted prose. Cluster, label, pull out the best. Structure is half the value.
• Refusing to commit. After diverging, take a position on what is actually promising. "Here are 20 ideas, you decide" is a cop-out. Generate wide, but converge with a real opinion.
• Skipping the isolation invariant. If you simulate parallel branches by writing them sequentially in one context, you have not done ADHD. You have done a wider single thought. The Agent/Task tool gives each branch a fresh context. Use it.

Calibration

• How many ideas? Scale to stakes. Quick "name this function" = 3 frames × 4 ideas. "How should I position this product" = 5 frames × 8 ideas. Default is 5 × 6 = 30.
• How weird? Read the room. Serious strategy work: flag the wild cards clearly so they do not read as unserious. Open brainstorming or play: let it run loose. Absurd ideas earn their place by seeding viable ones.
• When to stop diverging? Stop when new candidates start repeating the shape of existing ones. The space is mapped. Do not pad to hit a number.

Cost

5 diverge + 1 score + 1 cluster + 3 deepen ≈ 10 Agent calls per run. About 5 to 10x a single-shot answer. Not for every keystroke. For decision points where the cost of the obvious answer is high.

Companion library and CLI

There is a Node/TS implementation that does the same loop with structured JSON parsing, score weighting, and a CLI. Use it when running outside Claude Code or in batch.

npm install -g adhd-agent adhd "your problem here"

Code, paper, evals, and contributing guide at https://github.com/UditAkhourii/adhd. The skill above gives you the same loop inside Claude with no install required.

Source spec

This skill operationalises a written spec on divergent ideation. The original prose is preserved in SOURCE-SPEC.md for reference. The implementation choices made here (parallel isolated Agent calls, mechanical generator/critic split, frame-based branching) follow from that spec.