Adhd

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
License: MIT
Preprint: 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

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.

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.

Anti-Patterns

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 — academic paper
• Upstream repo
• The New Stack feature
• Independent benchmark
• Repowire integration
• Han research review

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