When Should I Not Use ADHD? Limitations vs Single-Shot Chain-of-Thought

Avoid ADHD for simple syntax queries, real-time applications, or deterministic workflows where single-shot Chain-of-Thought (CoT) suffices, as its parallel branch architecture introduces linear token costs and extra latency that outweigh benefits for straightforward problems.

The ADHD (Parallel Divergent Ideation for Coding Agents) framework in the UditAkhourii/adhd repository replaces traditional single-shot reasoning by spawning isolated reasoning branches under different cognitive frames—such as speedrunner, regulator, or biologist—then aggregating results through a separate critic pass. While this eliminates anchoring bias that plagues standard CoT, understanding when you should not use ADHD is critical for optimizing both cost and performance in production agent pipelines.

Situations Where You Should Avoid ADHD

Simple, Well-Defined Queries

Do not use ADHD for straightforward lookups or syntax questions. According to the skill definition in skills/adhd/SKILL.md (lines 3-5), you should skip the framework for "syntax, lookups, bugs with known root cause, or closed phrasing." The overhead of launching multiple branches—each requiring separate LLM calls—provides no value when a single-shot CoT already delivers a correct, deterministic answer.

Time-Critical or Low-Budget Environments

ADHD scales costs linearly with the number of branches (O(N × per_branch)), as documented in documentation/how-it-works.md (lines 49-50). For real-time assistants or cost-sensitive pipelines, this means latency and API spend can be 2-3× higher than single-shot CoT. When millisecond response times matter, the parallel generation overhead becomes prohibitive.

Human-in-the-Loop Workflows

Current evaluations show no proven benefit when human designers participate in the loop. A CHI 2025 study cited in documentation/evals.md (lines 44-46) found no significant improvement over baselines in collaborative scenarios. If your workflow relies on frequent human feedback, the extra divergence may add noise without measurable gain, making single-shot CoT more efficient.

Deterministic Output Requirements

Because ADHD samples many stochastic branches across different frames, final outputs can vary run-to-run even with temperature settings fixed. This non-determinism makes auditing, caching, and exact reproducibility harder compared to single-shot CoT, which maintains consistent reasoning paths.

Single Domain Expertise

ADHD’s strength lies in cross-domain frame recombination—combining perspectives like biology, logistics, or game design. As noted in documentation/when-to-use.md (lines 30-33), if your problem domain is already captured by a single expert frame, additional frames add little value and increase noise rather than insight.

Resource-Constrained Deployments

The architecture requires multiple independent LLM calls (generator plus critic passes), which may exceed the compute or token limits of on-device models or edge deployments. If you are running quantized LLMs on consumer hardware, the memory and inference costs likely prohibit ADHD usage.

Architectural Limitations vs Single-Shot Chain-of-Thought

Mechanical Separation of Generator and Critic

Unlike single-shot CoT, which maintains context within one request, ADHD enforces a strict mechanical split between generation and critique phases. As implemented in documentation/how-it-works.md (lines 76-77), this requires distinct system prompts and separate API calls, adding extra round-trip latency and increasing the API surface area compared to a unified CoT pass.

Loss of Incremental Reasoning

While branch isolation eliminates anchoring bias (a documented advantage in documentation/vs-cot-and-tot.md, lines 20-28), it also discards useful incremental reasoning. Single-shot CoT can build upon previous steps within a shared context, whereas ADHD’s isolated branches cannot leverage intermediate conclusions from sibling branches during generation.

Linear Token Cost Scaling

Single-shot CoT maintains constant cost per query, but ADHD’s cost grows proportionally with branch count. The relationship is strictly linear: cost ≈ N × per_branch_token_count. For high-volume applications, this scaling behavior fundamentally changes the economics of deployment compared to standard prompting.

Frame Engineering Complexity

Effectiveness depends entirely on the quality of IDEATION_FRAMES defined in src/frames.ts. Poorly designed frames generate irrelevant branches, requiring ongoing maintenance and expertise to curate effective cognitive perspectives. Single-shot CoT requires no such architectural maintenance.

Practical Implementation Examples

Running ADHD for Complex Problems

Use the CLI for exploratory, open-ended design tasks where cross-domain ideation provides value:

adhd "design a retry strategy for a CLI whose LLM hangs for 90s"

CLI syntax and flags are documented in documentation/api.md.

Programmatic Usage with Custom Frames

For Node.js/TypeScript applications, import from src/index.ts and configure specific frames via the engine in src/engine.ts:

import { adhd } from "adhd";

const problem = "How can we reduce latency of a distributed cache?";
const result = await adhd.run(problem, {
  frames: ["speedrunner", "regulator"],   // custom frame set
  branches: 6,                           // number of parallel divergences
});
console.log(result.bestIdea);

Fallback to Single-Shot CoT

When budgets are tight or determinism is required, bypass the branch architecture and use the underlying LLM wrapper directly from src/llm.ts:

import { llm } from "adhd/src/llm";

const singleShot = await llm.query("Explain the OAuth2 flow", {
  temperature: 0.0,   // deterministic
});
console.log(singleShot);

Summary

• Skip ADHD for syntax lookups, simple bugs with known causes, or closed-ended questions—use single-shot CoT instead.
• Token costs scale linearly (O(N × per_branch)) with the number of frames, making ADHD 2-3× more expensive than single-shot CoT.
• Latency increases due to separate generator-critic calls and the inability to share context between branches during generation.
• Human-in-the-loop workflows show no empirical benefit from ADHD divergence according to CHI 2025 evaluations.
• Reproducibility suffers because stochastic sampling across multiple frames introduces variability unsuitable for deterministic pipelines.
• Resource constraints on edge devices may prevent the multiple independent LLM calls required by the architecture.

Frequently Asked Questions

Is ADHD always better than single-shot CoT?

No. ADHD excels at cross-domain creative ideation where problems benefit from multiple vantage points (e.g., combining biology and logistics perspectives). For narrow, well-defined technical questions or deterministic requirements, single-shot CoT provides sufficient accuracy with lower latency and cost, as the pre-flight gate in skills/adhd/SKILL.md explicitly recommends.

How much more expensive is ADHD compared to standard prompting?

Costs scale linearly with branch count. If you configure six branches across three frames, expect approximately 6× the token consumption of a single-shot CoT query, plus additional overhead for the critic pass. This relationship is documented in documentation/how-it-works.md (lines 49-50).

Can I use ADHD with on-device or resource-constrained models?

Generally no. The architecture requires multiple independent LLM calls for the generator and critic phases, along with sufficient context windows to handle divergent branches. Most on-device or quantized models lack the compute budget and memory to execute the parallel generation pipeline effectively.

Does ADHD work well with human feedback loops?

Empirical evidence suggests no significant improvement. A CHI 2025 study referenced in documentation/evals.md (lines 44-46) found no measurable benefit over baselines when human designers participated in the workflow. For human-in-the-loop systems, the additional noise from divergent branches may actually complicate rather than enhance collaborative iteration.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}