Botmonster TechADHD gives your agent 30 ideas and kills 20 of them
ADHD is a coding agent ideation skill that fixes one habit: agents commit to their first idea and then defend it. It spawns several isolated model calls under different cognitive frames, then a separate critic call scores every idea and flags the traps. The project’s own eval puts trap detection at 9.50 against a baseline of 1.83.
Key Takeaways
- Coding agents lock onto their first idea, and better prompting doesn’t fix it.
- ADHD runs several separate calls that can’t see each other while they think.
- A second critic call scores the ideas, names the traps, and keeps the best few.
- The project’s own tests show the biggest gain in spotting bad-but-tempting ideas.
- It costs about twice the time and output, so save it for hard calls.
Why a coding agent settles on its first idea
A different project also called ADHD ships a set of output rules that stop an agent rambling. This post covers the idea-generation project instead.
A model writes its first plausible answer, then spends the rest of the response defending it.
Chain-of-thought doesn’t rescue you, because the reasoning arrives after the commitment. The model rationalises the answer it already picked instead of exploring past it.
Tree-of-thought gets closer, but only halfway. Branches widen the search, but they walk one shared context. By step four the model has anchored on steps one to three, so the first framing leaks into every branch.
The project’s own side-by-side shows the shape of the problem. The task was to design retry and timeout behaviour for a CLI that sometimes hangs for 90 seconds. The single-shot baseline walks four textbook patterns and lands on a hybrid. It sets a 15 second first-token timeout, 30 seconds between tokens, 90 seconds absolute, and one auto-retry.
What it never does is question the frame. Nobody asks whether the user might want to bail out of a slow request, or whether a different model would have been faster. Consequently the fix has to be structural, because a single call can’t un-see what it already wrote.
How the coding agent ideation skill diverges then focuses
ADHD splits ideation into two phases with a hard wall between them.
Divergence comes first. The skill picks several cognitive frames and spawns one parallel agent call per frame. Each call sees the problem plus that frame’s vantage prompt, and a system prompt that forbids evaluation, ranking, and hedging.
The isolation is the load-bearing part. Branches never see each other during divergence, so there’s no first answer to anchor on. Distinctness comes from the wiring, so no prompt has to beg for it.
Frames are not personas. The project ships 15 of them, and each is a vantage operator that re-poses the whole question. One thinks in latency and memory layout. Others re-ask the problem as a regulator, a 10-year-old, a speedrunner, or an ant colony with no central planner. Selection is deterministic per seed, and one wild slot is always reserved so the fan-out stays strange.
Focus comes second. A separate critic call runs with the opposite posture, and now judging is the job. It scores every idea on novelty, viability, and fit. Each trap gets tagged with the concrete reason it fails, such as a data store that breaks under multiple concurrent writers.
The critic also groups ideas by underlying angle, so you can argue about the shape of the design space instead of idea by idea. The top survivors get deepened into sketches with a named risk and a first concrete step. A separate field surfaces the most novel workable idea even when it isn’t the best fit.
| Approach | Threads | Branches share context | Generator and critic |
|---|---|---|---|
| Chain-of-thought | One, linear | Yes | Same step |
| Tree-of-thought | One tree, walked | Yes, one session | Same model, alternating |
| ADHD | Several, parallel, isolated | No | Separate calls, opposite prompts |
Two API calls with opposite system prompts give you a harder guarantee than any single prompt asking a model to self-critique.
That structure has a price. A default run makes about ten calls: five to diverge, one to score, one to cluster, and three to deepen. Token cost is worse than the call count suggests. Every branch reloads your base context before it writes a single new idea.
What the numbers say
The project publishes an eval table across six open-ended engineering problems, scored 0 to 10.
| Dimension | ADHD | Baseline | Ratio |
|---|---|---|---|
| Breadth | 9.00 | 4.83 | 1.9x |
| Novelty | 7.83 | 2.67 | 2.9x |
| Trap detection | 9.50 | 1.83 | 5.2x |
| Actionability | 9.50 | 6.50 | 1.5x |
| Builder usefulness | 7.67 | 6.83 | 1.1x |
Trap detection carries the whole result. Single-shot answers almost never name the seductive-but-broken option, while the critic pass routinely flags 15 to 20 of them with reasons.
Builder usefulness barely moves, which is the number a skeptic will find first.
The method is reasonable for a solo project. Both arms use the same model, an independent LLM judge scores them with a skeptical-staff-engineer prompt, and A/B order is randomised per problem. It also runs on only six problems with one judge family, all on the author’s own harness.
The published limitations go further. The judge shares a model family with the generator. The runs use five branches, while the academic diversity research measures at a hundred. A controlled CHI 2025 study also found no clear benefit when an LLM reframes a problem for human designers. That last one is counter-evidence the project chose to publish against itself.
The New Stack did the arithmetic on the headline claim and found trap detection is doing most of the lifting. Remove that one dimension and the average gain drops from 2.52x to 1.85x. Outside reviewers it interviewed were unconvinced by the sample size.
A ‘2x better’ claim needs more than a few open-ended wins. It needs a validated evaluation set, multiple judges, ablations, and evidence that the method improves without just rewarding verbosity, novelty, or branch diversity.
Robinson also called the pattern itself familiar, closer to parallel sampling and selection dressed up for engineering decisions. Andrew Moore, CEO of Lovelace AI and a former Google vice president, landed somewhere kinder in the same article.
The genuinely new idea [in ADHD] is finding another way to create diversity in a set of parallel thinkers.
One independent check exists. Shichinomiya ran a blind-scored duel against single-shot on two problems with the A/B positions swapped. ADHD won both, with novelty moving from 4.5 to 9.0 and trap detection from 5.0 to 9.0. Actionability went the other way, 8.5 for the baseline against 8.0, because textbook answers are concrete and ready to implement.
The same run measured the cost properly: 95.4 seconds against 216.1 seconds of wall time, and 5,623 characters of output against 10,697, so 2.26 times slower and 1.93 times longer.
The cost is real: ~2.3x time, ~1.9x output, and it burns through your quota fast (I hit the cap in a few runs).
When to reach for it and when it wastes money
Reach for it on architecture calls, API and CLI surface design, migration plans, naming, and strategy. It also suits fuzzy debugging, where you need whole classes of hunch you haven’t had yet. Anything phrased as “give me a few ways to” is in scope.
Skip it on lookup questions, bug fixes with a known root cause, mechanical refactors, and anything with one correct answer. Per-keystroke and tight-latency use is out too.
The tell is which question you would ask a colleague. If it is “how do I do this”, a single answer wins. If it is “what are the options here”, the fan-out earns its keep.
Double the time and output is cheap for a decision you live with for a year, and wasteful for one you revisit tomorrow. Nikolaos Vasiloglou of RelationalAI put the counterpoint to The New Stack: the method arrives while firms already struggle with runaway token bills.
Position it before planning rather than during implementation, so the plan starts from a pruned shortlist instead of a blank page. Other open-source agent projects have ported the same split into their own orchestrators, including repowire , whose maintainer mapped frames onto temporary peers.
The project is MIT licensed, written in TypeScript, and carries about 16 open issues. The runnable skill is a single SKILL.md you can read in one sitting.
How to install ADHD and run it on a real design question
Install the skill
Run npx skills add UditAkhourii/adhd. The installer detects Claude Code
, Cursor, Codex
, Cline, Gemini CLI, Windsurf, and dozens of others.
Fix the Codex path if needed
Some Codex builds only discover skills from their own directory. Force the target with npx skills add UditAkhourii/adhd -a codex -g, then restart Codex.
Pick a question worth the cost
Save it for design decisions, naming, API surfaces, and fuzzy debugging. A lookup or a known bug fix gets nothing from the fan-out.
Invoke it explicitly
The docs tell you to run /adhd "design a rate limiter that survives a leader election" yourself rather than hoping the auto-trigger fires.
Tune the fan-out
The CLI takes --frames, --ideas, and --top, so adhd "name this function" --frames 3 --ideas 8 --top 2 keeps a cheap question cheap. Install it with npm install -g adhd-agent.
Read the traps first
Each flagged idea comes with a one-line reason it looks good and is not. That is the sentence a single-shot answer never writes.
Use it as a library if you are building an agent
Run npm install adhd-agent and call run() from your own orchestrator. It returns the shortlist, the non-obvious pick, the trap list, the clusters, and the deepened sketches as structured data.