ADHD for Claude Code: parallel divergent ideation as an agent skill

The problem ADHD names: premature convergence in linear reasoning

The README frames the target problem precisely: linear Chain-of-Thought anchors on whatever it says first, and Tree-of-Thought widens the search but still walks a single shared context, so the anchoring persists across branches. The project treats this as an architectural problem rather than a prompting one. That distinction matters, because most prompting fixes for narrow answers amount to asking the same model, in the same context, to try harder.

Who it is for is stated just as plainly. The README says to reach for it on design decisions, fuzzy debugging, naming, API surface design, strategy, and any prompt of the shape give me a few ways to. That is a narrower audience than the phrase coding agent suggests. If your task has one correct answer that a test can check, divergent ideation adds cost without adding information. The skill earns its keep when the space of acceptable answers is wide and the failure mode is settling on the first reasonable one.

How the fan-out, scoring and pruning actually work

The mechanism described in the README has three stages. First, the skill spawns N isolated reasoning processes under deliberately distorted cognitive frames, with zero shared context during divergence. Isolation is the load-bearing part: because the branches do not see each other, they cannot converge on a shared phrasing early. Second, a separate critic pass scores and clusters the output. Third, that pass prunes traps and deepens the survivors.

The worked example in the README shows what the frames produce. On a problem about a CLI that hangs for 90 seconds, the run surfaces 30 or more ideas across clusters named economic-incentive, async-control-surface, gamification, perceptual-distortion, collective-intelligence and redundancy-race, then flags 20 traps with one-line reasons. The non-obvious pick it lands on is instant abort plus a branch to a cheaper, faster model, on the reasoning that the slow model might just be the wrong model for the prompt.

Two details in the package manifest tell you about the implementation. The dependencies are @anthropic-ai/claude-agent-sdk, p-limit and zod, so the parallelism is bounded by p-limit rather than unbounded, and the structured outputs from the critic pass are validated with zod schemas. The bin entry exposes an adhd command from dist/cli.js, and the repository carries a SOURCE-SPEC.md alongside skills/, which is where the frame definitions and the pipeline contract live. The README does not document what happens when a branch fails mid-run or how partial results are reported.

Installing ADHD and running a first divergent pass

The README gives a single install command that auto-detects the agent, listing Claude Code, Cursor, Antigravity, Codex, Cline, Gemini CLI, Windsurf and roughly fifty more. Node 18 or newer is required according to the engines field in package.json.

npx skills add UditAkhourii/adhd

After that, invoke the skill explicitly with /adhd, which is where the README's install section is truncated. The package also ships a standalone binary, so you can run the same pipeline outside an agent host. The dev script in package.json is tsx src/cli.ts and the built entry point is node dist/cli.js.

npx adhd-agent

The repository includes a bench harness with two entry points, a full eval run and a quick one, both driven by bench/run-evals.ts. If you want to reproduce the side-by-side comparison rather than take it on faith, those scripts and bench/results.json are the place to start.

npm run evals
npm run evals:quick

What you should expect from a first real run is a fan-out rather than a single answer: several branches, a scored and clustered shortlist, and an explicit list of rejected ideas with reasons. If you get one paragraph back, the skill did not run and you are looking at the host model's ordinary response.

Cost, framing risk and the cases where ADHD is the wrong tool

The honest limitation is implied by the design itself. Isolated branches under distorted frames cannot share context, which is exactly what produces breadth and exactly what produces noise. Some frames will generate ideas that are creative and useless, and the critic pass is the only thing standing between those and your shortlist. That pass is itself a model call, so the quality of the pruning depends on the same class of system whose convergence the skill was built to avoid.

Cost scales with N. Every additional frame is another full reasoning process, and the critic pass runs on top of all of them. For a naming question that is a reasonable trade. For a bug with a stack trace pointing at one line, it is waste.

The README's own example is instructive about a subtler risk. The winning idea on the retry problem is to abort and switch to a cheaper model. That is a good answer, and it is also the kind of answer a frame named economic-incentive is primed to produce. Frame selection shapes the output distribution, so the frame list is a design surface you should read before you trust the shortlist. The README does not document how frames are chosen per problem or whether a user can supply their own, though the skills/ directory is where that would live.

Where it sits next to Tree-of-Thought implementations

Tree-of-Thought is the natural comparison and the README makes it directly. A conventional Tree-of-Thought implementation explores multiple branches but keeps them in one shared context, so the model sees its earlier attempts while generating later ones and drifts back toward them. ADHD removes that shared context during divergence and adds a separate scoring stage afterward. The difference in approach is isolation plus a distinct critic, not a different search algorithm.

The practical consequence is that ADHD is not a drop-in replacement for a Tree-of-Thought library you already run inside a single prompt. It is a skill installed into an agent host, which means it inherits that host's model, tool access and billing. If you need the search to run inside your own application process with your own model client, the standalone CLI in this repository is the closer fit, and the package name adhd-agent is what you would depend on.

Licence, maintenance and what upgrading costs you

The project is MIT licensed, which permits commercial use, modification and redistribution provided the copyright notice and permission notice are retained. That is a permissive position with no copyleft obligation, but it says nothing about the model providers whose SDKs the package depends on. @anthropic-ai/claude-agent-sdk carries its own terms, and those govern the calls the skill makes, not the MIT grant covering this repository. That is a distinction to check with your own counsel rather than assume.

On maintenance: the repository is not archived, and the last push was on 2026-08-29. The most recent release is v0.1.4 from 2026-05-30, whose notes mention Codex compatibility and the first OSS adopter. The version has stayed in the 0.1.x line, and package.json pins the Claude Agent SDK at ^0.1.0, a caret range on a pre-1.0 dependency. That range means a fresh install can pull a newer SDK minor than the one the project was tested against. If you vendor this into a production agent, pin the resolved SDK version in your lockfile and re-run npm run evals after any SDK bump, because the bench harness is the only regression signal the repository ships.

Editorial conclusion

Adopt ADHD if your work is design decisions, API surface design, naming, strategy, or fuzzy debugging where the first plausible answer is often the wrong one, and you are willing to spend several parallel model calls per question. Skip it for routine edits, refactors, and anything where a deterministic answer already exists, because the fan-out buys breadth at the cost of tokens and latency. Before relying on it, verify three things yourself: that the installed skill directory matches the frame definitions in skills/, that your agent actually exposes the /adhd invocation after npx skills add, and that the bench/results.json transcripts were produced with a model version you can still run. The repository's last push was on 2026-08-29 and the newest release is v0.1.4 from 2026-05-30, so pin the version you adopt rather than tracking main.

Frequently asked questions

Official sources

1. License: MIT
2. Project website
3. README
4. Releases
5. UditAkhourii/adhd on GitHub