There's a dirty secret buried in how we use AI coding assistants: they almost always give you the same answer you'd get from Googling the problem. The model defaults to the first plausible solution and polishes it, producing output that's competent but forgettable—because it's literally the centroid of everything it saw during training. A developer named Udit Akhouri is calling this 'premature convergence,' and he's built something called ADHD (no relation to the actual disorder) that forces Claude Code and similar agents out of that rut.

How ADHD Breaks the Convergence Trap

The method—officially "Parallel Divergent Ideation for Coding Agents"—runs LLMs through a two-phase loop with a hard mechanical separation between generation and evaluation. In Phase 1, it spins up N parallel branches under completely different 'cognitive frames' (think: regulator, biology, speedrunner, $0 budget, ant colony). Crucially, these branches share zero context. The regulator branch never sees what the speedrunner branch produced, so anchoring is eliminated by construction, not by a polite prompt asking it to be creative. Phase 2 kicks in a separate critic pass that scores every idea on novelty, viability, and fit—then clusters them by underlying angle rather than surface keywords. Only the top-K survivors get deepened into full sketches with named risks and concrete first steps. The entire package lives at github.com/UditAkhourii/adhd as a Node/TypeScript library with an npm install (adhd-agent) CLI wrapper.

The Numbers Are Staggering

Akhouri tested ADHD against a strong single-shot baseline using six open-ended engineering problems: LRU cache design, CLI timeout strategies, distributed rate limiting, intermittent bug hunting, monolith decomposition, and feature flag naming. An independent LLM-as-judge evaluated outputs blinded as A/B pairs. ADHD won 5 out of 6 problems with mean improvements of +5.17 in novelty (7.83 vs 2.67 on a 0-10 rubric), +4.17 in breadth (9.00 vs 4.83), and a jaw-dropping +7.67 in trap detection (9.50 vs 1.83). That last number matters most: the baseline almost never flagged ideas that look good but are actually traps, while ADHD's adversarial scoring pass caught them consistently.

The One Problem Where It Lost

The lone loss came on a CLI timeout problem where the judge wrote: 'ADHD explores vastly more creative territory and expertly identifies traps, but the baseline delivers a pragmatic, immediately implementable solution.' When there's already a known-good answer sitting in the training distribution, ADHD's wide-angle exploration is overkill. The method earns its cost precisely when nobody knows what the right answer looks like yet.

Practical Tradeoffs You Should Know

A default run uses roughly 10 LLM calls versus 1 for the baseline. At concurrency-4, wall-clock time sits around 30–90 seconds. Akhouri frames it bluntly: 'Spend $0.30 to widen a $50k architecture decision.' The frame library ships with 15 vantage points tagged for code/design/general/wild use cases, and adding a new frame takes about five lines of TypeScript.

Key Takeaways

  • ADHD isn't prompting the model to think differently—it's architecting separate thinking instances that literally cannot see each other
  • The generator/critic split is mechanical (different LLM calls with incompatible system prompts), not a suggestion
  • Best use case: architectural decisions, API design, debugging fuzzy intermittent failures, refactor planning where obvious = wrong
  • Worst use case: anything with a Googleable answer or verifiable correct output

The Bottom Line

This is the first inference-time method I've seen that actually attacks premature convergence structurally instead of just asking nicely for creativity. If you're building anything where the 'textbook answer is often the trap,' ADHD deserves a spot in your toolkit—the npm package makes it dead simple to drop into existing Claude Code workflows.