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

> Discover when to avoid ADHD and its limitations compared to single-shot Chain-of-Thought. Learn when simpler methods suffice for efficient query processing and reduced latency.

- Repository: [Udit Akhouri/adhd](https://github.com/UditAkhourii/adhd)
- Tags: limitations
- Published: 2026-08-01

---

**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`](https://github.com/UditAkhourii/adhd/blob/main/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`](https://github.com/UditAkhourii/adhd/blob/main/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`](https://github.com/UditAkhourii/adhd/blob/main/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`](https://github.com/UditAkhourii/adhd/blob/main/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`](https://github.com/UditAkhourii/adhd/blob/main/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`](https://github.com/UditAkhourii/adhd/blob/main/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`](https://github.com/UditAkhourii/adhd/blob/main/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:

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

```

*CLI syntax and flags are documented in* [`documentation/api.md`](https://github.com/UditAkhourii/adhd/blob/main/documentation/api.md).

### Programmatic Usage with Custom Frames

For Node.js/TypeScript applications, import from [`src/index.ts`](https://github.com/UditAkhourii/adhd/blob/main/src/index.ts) and configure specific frames via the engine in [`src/engine.ts`](https://github.com/UditAkhourii/adhd/blob/main/src/engine.ts):

```typescript
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`](https://github.com/UditAkhourii/adhd/blob/main/src/llm.ts):

```typescript
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`](https://github.com/UditAkhourii/adhd/blob/main/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`](https://github.com/UditAkhourii/adhd/blob/main/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`](https://github.com/UditAkhourii/adhd/blob/main/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.