Adhd

---
name: adhd
description: Parallel divergent ideation for coding agents. Spawns N isolated branches under different cognitive frames (regulator, biology, speedrunner, 10-year-old, $0 budget), scores, clusters, prunes traps, and deepens top survivors. Use on /adhd, "ADHD mode", brainstorm/ideate intents, or open-ended design, architecture, naming, API/SDK surface, and fuzzy-debugging decisions. Skip for syntax, lookups, bugs with known root cause, or closed phrasing ("quick", "standard", "canonical", "textbook").
---

# [ADHD]

Stop picking the textbook answer. The first 3 answers the model would give are the answers a senior engineer would give in 30 seconds. Correct. Forgettable.

Interesting answers live past number 3, in the awkward middle nobody walks into. This skill makes the model walk there.

## [01]-[LOOP]

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

### [01.1]-[DIVERGE]

For the problem P, with frame and idea counts scaled per `[05]-[CALIBRATION]`:
1. Pick 5 cognitive frames from the table below. Bias toward engineering tags when the problem is code-shaped. Always include at least 1 wild frame to keep range.
2. Spawn 5 parallel Agent/Task tool calls. 1 per frame. Each Agent gets only:
- Problem P
- Context the user provided
- Chosen frame's vantage prompt
- System instruction that forbids evaluation

Exact instruction per Agent:
> You are in DIVERGENT mode. You are a generator, not a critic. Generate 6 short distinct ideas under this frame. Each idea is 1 phrase or 1 sentence.
> Do not evaluate. Do not rank. Do not hedge.
> The first 3 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": "..."}, ...]`

3. CRITICAL INVARIANT: 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.

### [01.2]-[FOCUS]

After all branches return:
1. SCORE: Rate each idea on 3 axes 0-10: novelty (distance from obvious default), viability (could it actually ship), fit (does it address the problem). For any idea that looks attractive but is a trap (hidden cost, false economy, will not scale, premature abstraction), flag it with a 1 line reason.
2. CLUSTER: Group ideas into 3-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".
3. DEEPEN THE TOP 3: Rank by weighted score (novelty 0.35 + viability 0.40 + fit 0.25), exclude traps, take the top 3. For each, spawn 1 Agent call that produces:
- 4-8 sentence sketch of how the idea works
- Load-bearing risk
- First concrete step a builder takes
- 3-5 child ideas (variations, hybrids, unlocks)

Deepen Agent instruction:
> You are in FOCUS mode. Take 1 promising idea and connect dots.
> Sketch how it would actually work in 4-8 sentences.
> Name the load-bearing risk. Name the first concrete step a coder would take.
> Then generate 3-5 sub-ideas that branch off (variations, combinations with other domains, things this unlocks).
> Output JSON only.

## [02]-[FRAMES]

| [INDEX] | [FRAME]                            | [VANTAGE_PROMPT]                                                                                                                                                      | [TAGS]                |
| :-----: | :--------------------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :-------------------- |
|  [01]   | hardware engineer                  | You think in latency, memory layout, and physical constraints. Re-ask this as a hardware/firmware problem. What does the bus topology, cache, timing budget tell you? | code, wild            |
|  [02]   | regulator                          | You audit systems for compliance and failure modes. What must be provable, traceable, or refusable here?                                                              | design, general       |
|  [03]   | 10-year-old                        | You are a curious 10 year old who has never seen software. Describe naive but unencumbered approaches. Ignore convention.                                             | general, wild         |
|  [04]   | competitor trying to break it      | You are a hostile competitor or attacker. Generate approaches that exploit, fail, or sabotage the obvious solution. Then invert into ideas.                           | code, design          |
|  [05]   | biology                            | Transplant a mechanism from biology (immune systems, neural plasticity, cell signaling, evolution, gut flora). Force-fit it onto this engineering problem.            | code, wild            |
|  [06]   | logistics                          | Steal mechanisms from logistics: queues, batching, just-in-time, hub-and-spoke, returns, last-mile. Apply them literally.                                             | code, design          |
|  [07]   | game design                        | Approach this as a game designer. What are the loops, rewards, friction, save-states, speedrun tricks? Treat the user as a player.                                    | design, general       |
|  [08]   | markets                            | Treat the problem as a market. Buyers, sellers, market-makers. What does an auction, a futures contract, a clearing house look like here?                             | design, wild          |
|  [09]   | inversion                          | Ask the OPPOSITE question. If goal is X, brainstorm how to guarantee NOT X. Then negate each answer back.                                                             | code, design, general |
|  [10]   | extreme: $0 budget, 1 hour         | No money, no team, one hour. What is the crudest version that still does the load-bearing thing?                                                                      | code, general         |
|  [11]   | extreme: infinite budget, 10 years | Infinite compute, infinite engineers, a decade. What is the maximalist version?                                                                                       | design, wild          |
|  [12]   | remove the load-bearing assumption | Name the thing everyone treats as fixed (framework, database, request-response model, network). Imagine it is gone. What is possible?                                 | code, design, wild    |
|  [13]   | speedrunner                        | You are a speedrunner. Find glitches, skips, out-of-bounds tricks, frame-perfect shortcuts. What is the abusive-but-legal path?                                       | code, wild            |
|  [14]   | ant colony                         | No central planner. Many dumb agents, local rules, pheromone trails. How does the problem solve itself emergently?                                                    | code, wild            |
|  [15]   | 3am on-call                        | You are the on-call engineer woken at 3am when this breaks. What design would let you not get paged?                                                                  | code, design          |

### [02.1]-[SELECTION]

For code-shaped problems: Pick 4 frames tagged `code` or `design`, and 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.

## [03]-[OUTPUT]

After `[01.2]-[FOCUS]`, render in this order. Do not collapse it into a wall of prose. The structure is the point.

1. BRIEF: 1-2 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 1 short phrase. Show score chips like `[N7 V8 F9]` next to each.
3. CONVERGE: 2-4 idea shortlist. State why each is on the list. Mark the non-obvious-but-viable pick explicitly with `[PICK]`. List traps separately, each with the 1 line reason it is a trap.
4. FOCUS: 3 deepened branches. For each: the sketch, the load-bearing risk, the first concrete step, and the child ideas.
5. PROVOCATION: 1 wildcard question or idea that opens a new direction the user can push into if nothing landed.

## [04]-[ANTI_PATTERNS]

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

- Weird-for-weird's-sake with no convergence: A pile of 30 unsorted absurdities is as useless as 1 safe answer. Always converge.
- Walls of equally-weighted prose: Cluster, label, pull out the best. Structure is half the value.
- Convergence disguised as divergence: 10 minor variations of 1 idea is not breadth. If every candidate shares the same underlying assumption, you have not diverged. You have decorated.
- 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.

## [05]-[CALIBRATION]

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