# What Is Parallel Divergent Ideation in AI Coding Agents: A Deep Dive into the ADHD Method

> Explore parallel divergent ideation in AI coding agents. Learn how this ADHD method generates diverse ideas and converges on optimal solutions for enhanced coding.

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

---

**Parallel divergent ideation is a two-phase algorithmic pattern that uses isolated, parallel Agent calls under distinct cognitive frames to generate a broad set of independent ideas before converging on the best solutions.**

In the open-source **ADHD** skill for Claude-based AI coding agents, parallel divergent ideation serves as the core mechanism for creative problem-solving. Developed by UditAkhourii, this approach deliberately trades computational cost for solution quality on open-ended, high-stakes problems like architecture design, API exploration, and fuzzy debugging.

## The Two-Phase Architecture

The ADHD implementation in [`src/engine.ts`](https://github.com/UditAkhourii/adhd/blob/main/src/engine.ts) strictly separates ideation into **diverge** and **focus** phases. Each phase operates under different constraints and produces different outputs.

### Phase 1: Diverge (Parallel Generation)

In the diverge phase, the system spawns multiple independent branches—each a fresh `query()` call via the Claude Agent SDK.

Each branch receives:

- The original problem statement
- User context (if provided)
- A unique **cognitive frame** (e.g., "hardware engineer", "speedrunner", "10-year-old")
- Instructions that **forbid evaluation or ranking**

The isolation invariant is critical: branches run **in parallel with no shared KV-cache or message history**. This prevents any single chain of thought from contaminating other perspectives. As specified in [`skills/adhd/SKILL.md`](https://github.com/UditAkhourii/adhd/blob/main/skills/adhd/SKILL.md), each branch must emit a JSON array of short, distinct ideas without hedging.

The default configuration uses 5 frames and requests 6 ideas per branch, though these are configurable via `frames` and `ideasPerFrame` parameters.

### Phase 2: Focus (Convergent Refinement)

Once all branches complete, the focus phase transforms the generator into a critic:

1. **Score** each idea on novelty, viability, and fit (0-10 scale)
2. **Cluster** ideas by underlying angle rather than surface keywords
3. **Deepen** the top-K ideas (default 3) with structured analysis including sketches, risks, first steps, and sub-ideas

The deepening calls run with a "FOCUS" system instruction, enabling evaluative reasoning that was explicitly forbidden in phase 1.

## Cognitive Frames and Their Role

The cognitive frames defined in [`src/frames.ts`](https://github.com/UditAkhourii/adhd/blob/main/src/frames.ts) are not mere stylistic variations. Each frame is a complete system prompt that shapes how the Agent interprets the problem space.

Common frame archetypes include domain experts (security engineer, UX researcher), constraint perspectives (minimalist, "move fast and break things"), and anthropomorphic lenses (curious child, skeptical auditor). By forcing the model to adopt these vantage points in isolated contexts, the system escapes the "awkward middle"—the predictable, median-quality solutions that single-prompt approaches tend to converge on.

## Resource Management and Concurrency

Despite the parallel structure, ADHD controls costs through a **semaphore-based concurrency limit**. The `concurrency` parameter (default 4) in [`src/engine.ts`](https://github.com/UditAkhourii/adhd/blob/main/src/engine.ts) caps simultaneous `query()` calls while preserving logical parallelism.

This makes the technique deliberately expensive—approximately 10 Agent calls per run—acceptable only when the cost of a wrong answer exceeds the compute cost of thorough ideation.

## Usage Examples

### CLI Usage

```bash

# Simple design brainstorming

adhd "design a rate limiter that survives a leader election"

# Tune breadth and depth parameters

adhd "name this feature-flag service" --frames 3 --ideas 8 --top 2

```

### TypeScript Library

```ts
import { run, renderText } from "adhd-agent";

const result = await run({
  problem: "How should we shard this queue under bursty load?",
  topK: 3,            // ideas to deepen
  frames: 5,          // cognitive frames
  ideasPerFrame: 6,   // ideas per branch
});

console.log(renderText(result));

```

### Direct Agent SDK (Illustrating Parallel Structure)

```ts
import { query } from "@anthropic-ai/claude-agent-sdk";

async function divergentBranch(framePrompt: string, problem: string) {
  return query({
    system: framePrompt,
    user: problem,
    instructions: [
      "You are in DIVERGENT mode. Generate 6 short distinct ideas.",
      "The first three obvious answers are banned. Output JSON only."
    ],
  });
}

```

## Key Implementation Files

| File | Purpose |
|------|---------|
| [`skills/adhd/SKILL.md`](https://github.com/UditAkhourii/adhd/blob/main/skills/adhd/SKILL.md) | Human-readable skill definition with pre-flight checks and phase workflow |
| [`src/engine.ts`](https://github.com/UditAkhourii/adhd/blob/main/src/engine.ts) | Orchestrates parallel calls, scoring, clustering, and deepening |
| [`src/frames.ts`](https://github.com/UditAkhourii/adhd/blob/main/src/frames.ts) | Cognitive frame definitions and system-prompt payloads |
| [`documentation/how-it-works.md`](https://github.com/UditAkhourii/adhd/blob/main/documentation/how-it-works.md) | Architectural deep-dive on the diverge-then-converge loop |
| [`documentation/quickstart.md`](https://github.com/UditAkhourii/adhd/blob/main/documentation/quickstart.md) | Usage guides for CLI, library, and agent-skill modes |

## Summary

- **Parallel divergent ideation** uses isolated Agent calls under distinct frames to force cognitive diversity
- **Strict phase separation** (diverge → focus) prevents premature evaluation from narrowing the idea space
- **Isolation invariants** (no shared cache, no message history) guarantee independent idea generation
- **Configurable parameters** (`frames`, `ideasPerFrame`, `topK`, `concurrency`) balance coverage against cost
- **Intended use** is high-stakes, open-ended problems where single-shot answers risk architectural dead-ends

## Frequently Asked Questions

### How does parallel divergent ideation differ from standard chain-of-thought prompting?

Chain-of-thought generates a single reasoning trajectory that can get stuck in local optima. Parallel divergent ideation, as implemented in [`src/engine.ts`](https://github.com/UditAkhourii/adhd/blob/main/src/engine.ts), forces **multiple completely independent trajectories** by isolating each branch's context. The scoring and clustering steps then select across this broader space rather than refining one path.

### When should I use ADHD instead of a direct Agent query?

According to [`documentation/how-it-works.md`](https://github.com/UditAkhourii/adhd/blob/main/documentation/how-it-works.md), use parallel divergent ideation when the problem is **open-ended, architectural, or lacks a known root cause**. For concrete lookups, precise bug fixes, or cases with clear success criteria, a direct query is more cost-effective. The ≈10x compute cost is justified only when exploration value exceeds execution overhead.

### Can I add custom cognitive frames to the system?

Yes. The frame table in [`src/frames.ts`](https://github.com/UditAkhourii/adhd/blob/main/src/frames.ts) is extensible. Each frame requires a unique identifier and a system prompt that defines the cognitive stance. The orchestration logic in [`src/engine.ts`](https://github.com/UditAkhourii/adhd/blob/main/src/engine.ts) treats frames generically, so custom frames integrate automatically into the parallel divergence phase without code changes.