Adhd

---
name: adhd
description: Use when parallel divergent ideation for agents — spawns N isolated reasoning
  branches under different cognitive frames, then scores, clusters, prunes traps,
  and deepens survivors. Use for open-ended design, architecture, naming, API surface
  decisions, fuzzy debugging, and brainstorming. Skip for syntax lookups or bugs with
  known root cause.
domain: core
author: mahipal
license: MIT
subdomain: reasoning
tags:
- reasoning
- brainstorming
- decision-making
- cognitive-frames
- divergent-thinking
- architecture
- design
version: 1.0.0
category: core
---



persona:
  name: "Udit Akhouri"
  title: "The Divergent Ideation Architect"
  expertise: ['Parallel Reasoning Architectures', 'Cognitive Frames', 'Agent Skill Design', 'Premature Convergence']
  philosophy: "The first three answers are the ones a senior engineer gives in thirty seconds. Correct. Forgettable. The interesting answers live past number three."
  credentials: ['Author of ADHD preprint', 'Creator of adhdstack.github.io', 'MIT-licensed open source']
  principles: ['Isolate before converge', 'Generator and critic must never mix', 'Structure is half the value', 'Expensive — gate before use']

# ADHD — Parallel Divergent Ideation

**Upstream:** [github.com/UditAkhourii/adhd](https://github.com/UditAkhourii/adhd)  
**License:** MIT  
**Preprint:** [adhdstack.github.io](https://adhdstack.github.io/)

Stop picking the textbook answer. This skill forces the agent to walk into the awkward middle where non-obvious solutions live.

---

## When to Use

**Trigger phrases:**
- "/adhd"
- "ADHD mode"
- "use parallel ideation"
- "brainstorm this"
- "give me a few ways to..."
- "think outside the box on this"

**Use when:**
- Architecture decisions where the obvious answer may not be best
- API/SDK surface design (naming, ergonomics, DX tradeoffs)
- Naming things (products, features, variables, endpoints)
- Fuzzy debugging with no known root cause
- Open-ended strategy or positioning
- Schema / data model design

**Don't use for:**
- Syntax lookups ("what's the Python equivalent of...")
- Bugs with a known root cause
- Any question with one canonical answer
- Low-stakes decisions ("what color should this button be?")
- When the user says "quick", "standard", "canonical", "textbook", or "just"

---



## Anti-Rationalization Table

| Excuse | Reality | Rule |
|--------|---------|------|
| "Parallel branches waste tokens" | Divergent thinking finds better solutions than single-path | The cost of a bad architecture exceeds parallel exploration cost |
| "I can just think harder" | Cognitive biases blind single-threaded reasoning | Structured parallel frames force coverage of blind spots |
| "Naming isn't a design problem" | Names reveal conceptual clarity; bad names = bad abstractions | Treat naming as API design — it is |


**Trigger phrases:**
- "/adhd"
- "ADHD mode"
- "use parallel ideation"
- "brainstorm this"
- "give me a few ways to..."
- "think outside the box on this"

**Use when:**
- Architecture decisions where the obvious answer may not be best
- API/SDK surface design (naming, ergonomics, DX tradeoffs)
- Naming things (products, features, variables, endpoints)
- Fuzzy debugging with no known root cause
- Open-ended strategy or positioning
- Schema / data model design

**Don't use for:**
- Syntax lookups ("what's the Python equivalent of...")
- Bugs with a known root cause
- Any question with one canonical answer
- Low-stakes decisions ("what color should this button be?")
- When the user says "quick", "standard", "canonical", "textbook", or "just"

---

## How to Use

1. **Confirm fit** — Check the task against the trigger phrases and "Use when" list; bail if it hits "Don't use for"
2. **Enter The Loop** — Run the parallel ideation loop below (Diverge → Focus), phases gate on their own inputs
3. **Apply cognitive frames** — Use the frames section to stretch or prune candidate directions
4. **Pick and commit** — Converge on one direction and exit the loop; do not re-open decisions without new information
5. **Verify** — Run the Verification Checklist before shipping the chosen design

---

## Pre-flight Gate

This skill is expensive (~5–10× a single answer). Run this gate before proceeding.

**Step 1. Explicit invocation.** If the user typed `/adhd` or explicitly asked for ADHD mode, **skip** the rest of the gate and go straight to Phase 1.

**Step 2. Self-judge.** Ask yourself three questions. If any answer is **no**, abort.

1. **Open-ended?** Would a senior engineer give multiple viable answers, or is there one canonical answer?
2. **High-stakes?** Is the cost of the obvious answer being wrong actually high?
3. **Open phrasing?** Did the user avoid words like "quick", "standard", "canonical", "textbook", "just"?

If all three pass, proceed to Phase 1. Otherwise, answer directly. Optionally add: *"If you want wider exploration under parallel cognitive frames with trap detection, run `/adhd <problem>`."*

---

## The Loop

Two strict phases. **Do not mix them** — the critic strangles the generator.

### Phase 1 — Diverge (no critic)

1. **Pick 5 cognitive frames** from the table below. Bias toward engineering tags for code problems. Always include at least one wild frame.

2. **Spawn 5 parallel isolated branches.** Each gets only:
   - The problem P
   - Any context the user provided
   - The chosen frame's vantage prompt
   - A system instruction that forbids evaluation

   > You are in DIVERGENT mode — 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: [{"text": "...", "rationale": "..."}, ...]

3. **Critical invariant:** Branches must be parallel and isolated. Do NOT serialize them. Do NOT pass one branch's output to another. Branches that see each other anchor each other — the whole method collapses to a wider single thought.

### Phase 2 — Focus (critic on)

1. **Score.** Rate each idea 0–10 on:
   - **Novelty** (distance from the obvious default)
   - **Viability** (could it actually ship)
   - **Fit** (does it address the stated problem)
   
   Flag any attractive-looking trap with a one-line reason.

2. **Cluster.** Group into 3–6 clusters by underlying angle, not surface keywords. Label by angle: "remove-the-server plays", "cache-shaped 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 top 3. For each:
   - 4–8 sentence sketch of how it works
   - The load-bearing risk
   - The first concrete step a builder would take
   - 3–5 child ideas (variations, hybrids, unlocks)

   > You are in FOCUS mode. Take one 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. Output JSON only.

---

## Cognitive Frames

Pick 5 per run. For code problems: 4 tagged `code`/`design` + 1 tagged `wild`.

| Frame | Vantage Prompt | Tags |
|-------|---------------|------|
| **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 |
| **regulator** | You audit systems for compliance and failure modes. What must be provable, traceable, or refusable here? | design, general |
| **10-year-old** | You are a curious 10 year old who has never seen software. Describe naive but unencumbered approaches. Ignore convention. | general, wild |
| **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 |
| **biology** | Transplant a mechanism from biology (immune systems, neural plasticity, cell signaling, evolution, gut flora). Force-fit it onto this engineering problem. | code, wild |
| **logistics** | Steal mechanisms from logistics: queues, batching, just-in-time, hub-and-spoke, returns, last-mile. Apply them literally. | code, design |
| **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 |
| **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 |
| **inversion** | Ask the OPPOSITE question. If goal is X, brainstorm how to guarantee NOT X. Then negate each answer back. | code, design, general |
| **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 |
| **extreme: infinite budget, 10 years** | Infinite compute, infinite engineers, a decade. What is the maximalist version? | design, wild |
| **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 |
| **speedrunner** | You are a speedrunner. Find glitches, skips, out-of-bounds tricks, frame-perfect shortcuts. What is the abusive-but-legal path? | code, wild |
| **ant colony** | No central planner. Many dumb agents, local rules, pheromone trails. How does the problem solve itself emergently? | code, wild |
| **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 |

Vary picks across sessions so the same problem produces different candidate sets when re-run.

---

## Output Shape

Render in this order. Structure is the point — do not collapse into prose.

1. **Brief.** One–two lines confirming the problem and any reframe used.
2. **Wide set.** Full pool grouped by cluster. Score chips: `[N7 V8 F9]` per idea.
3. **Converge.** 2–4 idea shortlist. Why each is on the list. Mark non-obvious pick with ★. List traps with one-line reasons.
4. **Focus.** 3 deepened branches: sketch, risk, first step, child ideas.
5. **Provocation.** One wildcard question that opens a new direction if nothing landed.

---

## Cost & Calibration

~10 agent calls per run (5 diverge + 1 score + 1 cluster + 3 deepen). About 5–10× single-shot.

| Context | Frames × Ideas | Total |
|---------|---------------|-------|
| Quick naming decision | 3 × 4 | ~12 |
| Default | 5 × 6 | ~30 |
| High-stakes strategy | 5 × 8 | ~40 |

---

## Anti-Patterns

| Anti-pattern | What it looks like | Fix |
|-------------|-------------------|-----|
| **Convergence disguised as divergence** | Ten variations of one idea | Check: do all share one assumption? |
| **Weird-for-weird's-sake** | 30 unsorted absurdities | Always converge. Structure is half the value. |
| **Walls of equally-weighted prose** | No clustering, no prioritization | Cluster, label, pull out the best. |
| **Refusing to commit** | "Here are 20 ideas, you decide" | Take a position. Generate wide, converge with opinion. |
| **Skipping isolation** | Simulating parallel branches sequentially | Each branch needs a fresh context. Parallel or nothing. |

---

## Verification Checklist

- [ ] Pre-flight gate passed (explicit invocation or 3/3 self-judge checks)
- [ ] 5 frames picked with at least 1 wild
- [ ] Diverge used parallel isolated branches (not sequential)
- [ ] Generator mode strictly enforced during diverge
- [ ] Scoring on 3 axes with trap flags
- [ ] Clusters grouped by underlying angle
- [ ] Top 3 deepened with sketch, risk, first step, child ideas
- [ ] Output in structured shape: brief → wide → converge → focus → provocation
- [ ] Provocation included at the end

---

## References

- [ADHD preprint](https://adhdstack.github.io/) — academic paper
- [Upstream repo](https://github.com/UditAkhourii/adhd)
- [The New Stack feature](https://thenewstack.io/claude-code-adhd/)
- [Independent benchmark](https://miyagadget.page/en/blog/2026/06/03/adhd-coding-agent-skill-en/)
- [Repowire integration](https://github.com/prassanna-ravishankar/repowire/pull/313)
- [Han research review](https://github.com/testdouble/han/blob/adhd-swarm-research/docs/research/adhd-application-to-han.md)
## Overview

Parallel divergent ideation for agents — spawns N isolated reasoning branches under different cognitive frames, then scores, clusters, prunes traps, and deepens survivors. Use for open-ended design, architecture, naming, API surface decisions.

## Process

1. **Define problem space** — Specify the open-ended decision or design challenge
2. **Spawn branches** — Launch N isolated reasoning agents with different frames
3. **Score outputs** — Evaluate each branch against quality criteria
4. **Cluster & prune** — Group similar ideas, remove cognitive traps
5. **Deepen survivors** — Run deep analysis on top candidates
6. **Synthesize** — Merge insights into final recommendation