Adhd

ADHD: Divergent Ideation Framework

A structured process for generating and evaluating multiple non-obvious options when you need to make a decision. This skill uses parallel thinking frames to surface alternatives you might not naturally consider.

When to use

Use ADHD when:

• You're at a decision point with multiple viable approaches
• You want to ensure you've considered non-obvious alternatives
• The decision has meaningful stakes (implementation cost, architectural impact, user experience)
• You're unsure which direction to take

Do NOT use for:

• Trivial decisions (variable names, obvious bug fixes)
• Decisions already made or constrained by requirements
• Linear problems with a single clear solution
• Time-sensitive situations where rapid execution matters more than thoroughness

Cost profile

ADHD is 5-10× more expensive than normal ideation:

• N parallel divergence agents (typically 5-7)
• K parallel deepen agents (typically 3)
• Inline scoring and clustering by main agent

Use this when the decision justifies the cost.

Process Overview

digraph adhd {
    "Invoke /adhd or\nbrainstorming delegates" [shape=box];
    "Score raw ideas\n(inline by main agent)" [shape=box];
    "Cluster ideas\n(inline by main agent)" [shape=box];
    "Diverge (N frames)\nparallel Agent calls" [shape=box];
    "Deepen (K clusters)\nparallel Agent calls" [shape=box];
    "Render output\n(options + critiques)" [shape=box];
    "Release control\nto normal agent loop" [shape=doublecircle];

    "Invoke /adhd or\nbrainstorming delegates" -> "Diverge (N frames)\nparallel Agent calls";
    "Diverge (N frames)\nparallel Agent calls" -> "Score raw ideas\n(inline by main agent)";
    "Score raw ideas\n(inline by main agent)" -> "Cluster ideas\n(inline by main agent)";
    "Cluster ideas\n(inline by main agent)" -> "Deepen (K clusters)\nparallel Agent calls";
    "Deepen (K clusters)\nparallel Agent calls" -> "Render output\n(options + critiques)";
    "Render output\n(options + critiques)" -> "Release control\nto normal agent loop";
}

The Process

1. Diverge (N frames in parallel)

Spawn N parallel subagents via the Agent tool (model: haiku for speed), each using a different thinking frame from frames.md. Each agent generates 3-5 raw ideas through their assigned frame's lens.

All divergence agents MUST be dispatched in a single message (parallel execution is mandatory).

Available frames (choose 5-7 based on context):

1. Constraint inversion
2. Opposite day
3. Time travel (10 years forward/back)
4. Cross-domain analogy
5. Stakeholder rotation (become user/admin/API consumer)
6. Failure pre-mortem
7. Sensory shift
8. Scale extremes (10× bigger/smaller)
9. Role reversal
10. Material substitution
11. Process reversal
12. Success post-mortem
13. Beginner's mind
14. Expert blind spots
15. Adjacent possible

See frames.md for detailed frame descriptions and prompts.

2. Score (inline by main agent)

After all divergence agents complete, summarize their outputs in your next turn (you cannot intercept tool_result blocks). Review all raw ideas and score each on:

• Novelty (1-5): How non-obvious is this?
• Viability (1-5): Can this actually work?
• Impact (1-5): Does this meaningfully improve outcomes?

Discard ideas scoring <3 on any dimension.

3. Cluster (inline by main agent)

Group surviving ideas by similarity into K clusters (typically 3-5). Each cluster represents a distinct strategic direction.

4. Deepen (K clusters in parallel)

For each cluster, spawn a parallel subagent via the Agent tool (model: sonnet for depth) to:

• Develop the cluster's core approach
• Identify implementation requirements
• Surface hidden costs and risks
• Generate adversarial critique

All deepen agents MUST be dispatched in a single message (parallel execution is mandatory).

Nesting fallback: If deepen agents fail due to nesting depth (e.g., ADHD invoked from brainstorming), run deepen sequentially in-context instead of dispatching subagents. This fallback is for dispatches that were attempted and failed — a dispatch tool named something other than Agent is still the dispatch tool, and never triggers it.

5. Render Output

Present results in this structure:

## ADHD Output: [decision topic]

### Option A: [cluster name]
**Core approach**: [1-2 sentences]
**Why this works**: [bullets]
**Hidden costs**: [bullets]
**Critique**: [adversarial assessment]

### Option B: [cluster name]
...

### Option C: [cluster name]
...

**Recommendation**: [which option and why, or "no clear winner — here's what each optimizes for"]

6. Standalone Exit

After rendering output for an explicit /adhd invocation, release control to the normal agent loop. The user can continue the conversation, ask clarifying questions, or choose an option.

HARD-GATE: This skill does NOT trigger mandatory checklist items, does NOT block implementation, and does NOT alter the brainstorming process graph. It is an advisory subroutine only.

Context Handling

When divergence or deepen agents complete, their raw output appears in tool_result blocks. You cannot intercept these blocks. Instead:

In your next turn after agent results arrive, summarize the key findings before proceeding to the next phase. This keeps the conversation coherent and avoids burying results in tool output.

Example:

"The divergence agents returned 23 raw ideas across 5 frames. After scoring, 12 survived (novelty ≥3, viability ≥3, impact ≥3). These cluster into 3 strategic directions: [A], [B], [C]. Now running deepen agents on each cluster..."

Integration with Brainstorming

The brainstorming skill offers ADHD to the user during checklist step 4, "Resolve gray areas" (see its Gray Areas → Step 0). The offer is an AskUserQuestion whose recommended answer is the cheap no-ADHD path, so this remains opt-in, not a gate.

That delegation is discovery-framed: the decision point handed to ADHD is "what latent ambiguous decisions are in this request?", so the options you return are candidate gray areas, not solutions. Frames that hunt blind spots — failure pre-mortem, stakeholder rotation, expert blind spots — fit this best.

Your returned areas are additive: brainstorming dedupes them against its standard catalog set and appends the survivors as extra choices. Nothing you return replaces a catalog area, so don't try to restate or improve on the standard ones — aim for what the catalog would miss.

Brainstorming may also delegate mid-design for ordinary option generation:

"This decision has high uncertainty across [areas]. I'm going to use the ADHD skill to surface non-obvious options."

Either way, treat delegation as an explicit invocation — run the full ADHD process and return the structured output.

Reference Materials

• frames.md — Full descriptions of all 15 divergent-thinking frames
• reference/when-to-use.md — Expanded guidance on appropriate use cases
• reference/divergence-prompts.md — Quirk-specific prompt templates for divergence agents
• SOURCE-SPEC.md — Original design rationale and upstream source
• UPSTREAM-LICENSE — MIT license (required for compliance)

Attribution

This skill is based on the upstream ADHD divergent-thinking framework. It has been adapted for the Quirk skills library with the following additions:

1. Standalone exit + context handling: After rendering output for explicit /adhd, the skill releases control to the normal agent loop. Context handling clarified as "summarize in next turn" (cannot intercept tool_result blocks).

2. Nesting fallback: If deepen agents fail due to nesting depth (e.g., ADHD invoked from brainstorming), run deepen sequentially in-context instead of dispatching subagents.

3. Score/Cluster inline: Score and Cluster phases run inline by the main agent — only Diverge (N) and Deepen (K) use the Agent tool.

See UPSTREAM-LICENSE for the original MIT license.