AuDHD — divergent ideation for coding agents

Two neurotypes, one method. The ADHD half scatters — isolated reasoning branches under distorted cognitive frames, zero shared context, so nothing anchors. The autistic half systematizes — a skeptical staff-engineer critic that scores every idea on fixed axes, clusters by underlying angle, and hunts traps without mercy. Divergence and relentless convergence. Neither half alone is the method; the tension between them is.

Your coding agent can reason, but it won't ideate. Ask it for a few different approaches and what comes back is the same idea reworded — because it reaches for the highest-frequency pattern in its training data. The first three answers it gives are the answers a senior engineer gives in thirty seconds: correct, forgettable. The interesting answers live past number three, in the awkward middle nobody walks into. AuDHD makes the model walk there.

Reach for it on design decisions, fuzzy debugging, naming, API/SDK surface design, strategy, test planning, pre-ship audits — any prompt of the shape "give me a few ways to…".

---

Lineage & credit

AuDHD is a fork of UditAkhourii/adhd by Udit Akhouri (MIT) — a genuinely good piece of work, and the source of everything load-bearing here:

• the cognitive-frame library (15 frames + their vantage prompts)
• the diverge → focus loop
• the isolation invariant (parallel branches, zero shared context)
• the pre-flight gate

The upstream project named the divergence — the ADHD. This fork names the convergence too: the systematizing, trap-hunting critic that, in our implementation, does equal work. Hence AuDHD (autistic + ADHD). That's the whole reason the fork exists, plus two things we added:

1. Two field recipes — test-strategy planning and pre-ship UX/churn auditing.
2. A Claude Code power-mode engine that runs each branch in a genuinely separate agent context (real isolation, not a simulated single thought).

If you build on this, keep NOTICE and credit the upstream project. The method is theirs; we stood on it.

---

Install

As a skill (any supported agent):

npx skills add scrappylabsai/audhd

Then invoke explicitly with /audhd "your problem", or let it auto-trigger on open-ended ideation intents. (If your agent uses a .claude/ skills folder rather than .agents/, move the skill there — see your agent's skill docs.)

Manually: copy skills/audhd/SKILL.md into your agent's skills directory. It's a single self-contained file — no dependencies.

---

How it works

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

Phase 1 — Diverge (no critic). Pick 5 cognitive frames. Spawn 5 parallel, isolated sub-agents, one per frame. Each gets only the problem, your context, and its frame's forced vantage — plus an instruction that bans the first three obvious answers and forbids evaluation. The branches never see each other. That isolation is the point: branches that can see each other anchor each other.

Phase 2 — Focus (critic on). One skeptical pass scores every idea on novelty / viability / fit (0–10), flags traps (seductive-but-broken ideas) with reasons, clusters by underlying angle, and shortlists the survivors — ranked by a weighted score, traps excluded.

Phase 3 — Deepen. The top 3 survivors each get expanded into a sketch, the one load-bearing risk, a first concrete step, and 3–5 child ideas.

You get a structured report — wide set with [N V F] score chips, a converged shortlist with the best non-obvious pick starred, named traps, and deepened branches — not a wall of prose.

---

Power mode (Claude Code)

The skill runs anywhere you can spawn parallel sub-agents. If you use Claude Code with the Workflow tool, workflow/audhd.js runs the exact same loop with structured JSON schemas and real per-branch isolation:

Workflow({
  scriptPath: "workflow/audhd.js",
  args: {
    problem: "how should we design the retry/timeout/UX strategy for a CLI that calls an LLM",
    context: "optional extra context",
    ideas: 6,   // ideas per frame; bump to 8 for high-stakes strategy
    topK: 3,    // survivors to deepen
    seed: 0     // bump to re-run the SAME problem with different frames
  }
})

---

When to use it (and when not to)

Use it for open-ended, high-stakes decisions with more than one viable answer: architecture, naming, public API surface, schema design, strategy, fuzzy bugs with no known root cause.

Skip it for factual lookups, syntax, bugs with a known root cause, or anything you phrased as "quick", "standard", "canonical", or "textbook". The skill has a built-in pre-flight gate that self-checks all of this before spending ~10 agent calls — it won't fire on the cheap stuff.

Recipes

• Test-strategy planning (TDD, before you build). Point it at how to test. Each branch returns a testing direction — edge cases, performance paths, alternate routes — that a single test-author pass misses. You get a plan, not tests; pick a branch and hand it to the coding agent to implement.
• Pre-ship UX / churn audit (before you launch). Point it at a built feature and ask where real users churn. It surfaces a wide findings set and catches gaps a linear review skips — including spec-promised features that never got built.

Both share the rule: AuDHD plans and audits, it never implements.

---

License

MIT — see LICENSE and NOTICE. Forked with gratitude from UditAkhourii/adhd.

Built by ScrappyLabs. Bring your own AI. We keep the bots wrangled.