Adhd: Agents Need Better Ideas
github.com/UditAkhourii/adhd | License: MIT
A coding agent gets stuck in a familiar loop: first decent answer, slight refinement, then false confidence. That pattern looks smart until the task is messy, creative, or strategic, e.g. API design, naming, debugging something weird. Adhd attacks that failure mode head-on. Instead of begging a model to “brainstorm harder,” the repo treats bad ideation as an architectural flaw. That framing is way more interesting than another prompt pack, because it turns creativity from a vibe into a system.
The Drop: When Smart Models Fixate Early
ChatGPT, Claude, and every coding copilot look broad until a fuzzy problem shows up. Ask for a retry strategy, a product surface, or a non-obvious refactor, and the model usually locks onto its first respectable answer. That is premature convergence, the repo’s core target, where autoregressive models keep building on an early thought because the conversation itself becomes an anchor.
Adhd exists because ordinary chain-of-thought is linear, and even tree-of-thought often shares too much context between branches. Shared context sounds efficient, but it also means the same bias contaminates every path. The result is familiar: polished sameness, textbook answers, and very few genuinely weird but useful options. For creative coding work, that’s a tax on judgment.
What makes the frustration feel real is that better prompting rarely fixes it. A longer prompt just gives the model more room to rationalize the same direction. Adhd starts from a harsher assumption: if the reasoning process keeps collapsing into one lane, the lane itself has to be rebuilt.
The Stack: TypeScript With Agent-Native Plumbing
Under the hood, Adhd is a TypeScript package designed for the Claude and Codex agent ecosystems, with a CLI and installable skill format. The repo centers on a small engine, frame selection logic, rendering, eval tooling, and tests, all wired for Node-based agent workflows rather than a standalone app.
The Sauce: Isolated Frames, Then a Separate Judge
Here’s the architectural bet: Adhd creates multiple isolated reasoning branches under different cognitive frames, deliberate perspective shifts like economic incentives, redundancy, or user-control bias, and keeps those branches from seeing each other during divergence. That isolation matters. A normal multi-branch setup still lets branches inherit the same conversational gravity. Adhd cuts that thread.
After divergence, a separate critic pass scores the ideas, clusters similar ones, flags traps, and decides which branches deserve more depth. This is not just “generate lots of options.” It is a two-stage system where exploration and judgment are intentionally split. Think Notion templates versus a workflow engine. One gives you reusable text. The other gives you process.
The project’s other sharp move is treating bad ideas as first-class output. Trap pruning means the system doesn’t merely rank promising directions, it explicitly identifies seductive dead ends before they burn time. That’s unusually practical for agent tooling, because in product and engineering work the expensive mistake is often not missing the best idea, it’s shipping the plausible bad one.
Finally, Adhd formalizes divergent ideation as something composable inside other agent systems. Early adopters are already wiring the pattern into plugin marketplaces, codebase explainers, and orchestration frameworks. Honestly, that portability seems like the bigger story. The repo is less a clever prompt than a reusable reasoning primitive.
The Move: Put It Where Ambiguity Costs Money
Three use cases jump out immediately: product strategy, software architecture, and fuzzy debugging. Drop Adhd into an agent workflow whenever a team needs options before execution, e.g. naming an API surface, deciding timeout behavior, or unpacking why a codebase feels brittle without an obvious culprit. Those are exactly the moments where default assistants sound competent but narrow.
Founders and PMs could use it upstream of specs. Instead of asking one model for “the best approach,” run a structured spread of competing angles, then inspect which survivors keep showing up after scoring and clustering. That gives a stronger basis for tradeoff decisions, especially when teams need novelty without chaos.
Tool builders have the clearest opening. Adhd can become a premium layer inside AI IDEs, internal copilots, or research products, where the value is not raw generation but decision quality. A product that consistently surfaces one non-obvious, high-leverage path gains trust fast. In markets crowded with generic copilots, better ideation is not a nice-to-have. It is differentiation users can feel in a single session.
The Aura: Creativity Stops Feeling Mystical
People already expect AI to answer fast. The next expectation is stranger: AI should help break mental ruts, not just accelerate them. Adhd taps into that shift by making alternative perspectives operational instead of accidental.
That changes the relationship between human judgment and machine output. Instead of treating the first polished answer as wisdom, teams can treat reasoning like a search space with failure modes. That is psychologically important. It trains better skepticism, better exploration habits, and a healthier default around model confidence. The machine still proposes, but the human gets a wider field to choose from.
The Play: A Reasoning Primitive, Not Just a Plugin
From a VC lens, Adhd looks less like a 0-to-1 standalone category and more like a sharp enabling layer for the exploding agent tooling stack. TAM is broad because every AI coding, research, and workflow product eventually runs into the same issue: models converge too early on ambiguous tasks. PMF signals are promising for an infrastructure-style repo, 3,782 stars quickly, active community channels, published evals, and real downstream integrations. The moat is not data yet. The moat is execution speed, ecosystem embedment, and becoming the default pattern for high-ambiguity reasoning inside other products.
Winners:
Wordware: Better workflow outputs compound because structured ideation can turn fragile prompt chains into more resilient decision systems for non-technical builders.
Cursor: Higher-quality exploratory reasoning can raise LTV by making the assistant more useful before code is written, not just while editing files.
Atlassian: Richer planning and specification workflows get stickier if AI can surface competing implementation paths and obvious traps inside Jira and Confluence.
Losers:
Factory: Narrow copilot positioning erodes if users start expecting architecture-level exploration rather than faster autocomplete with nicer packaging.
Jasper: Template-heavy AI workflows lose edge when buyers want systems that generate and critique multiple directions instead of polishing one default answer.
GitHub: Generic assistant expectations get tougher to defend if open reasoning layers make premium coding help feel more differentiated outside Copilot.
tl;dr
Adhd turns agent brainstorming into a real architecture: isolated reasoning branches, separate critique, and explicit trap detection. That is clever because it tackles fixation as a systems problem, not a prompting problem. Worth a look for anyone building AI coding tools, research assistants, or decision-heavy workflows.
Stars: 3,782 | Language: TypeScript
