# How ADHD's Two-Phase Diverge-and-Focus Loop Works: A Deep Dive into the Creative Engine

> Uncover ADHD's unique two-phase Diverge-and-Focus loop. Learn how this creative engine drives innovation through alternating idea generation and deep refinement. Explore the technical implementation.

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

---

**ADHD implements a "Steve-Jobs-style" creative loop that strictly alternates between wide-angle idea generation (Diverge) and deep, focused refinement (Focus), implemented in [`src/engine.ts`](https://github.com/UditAkhourii/adhd/blob/main/src/engine.ts) with separate system prompts for each phase.**

The ADHD repository from UditAkhourii/adhd is an open-source creative problem-solving engine that mimics how breakthrough thinkers work: first expanding broadly across multiple cognitive angles, then selectively deepening the most promising paths. This two-phase **Diverge-and-Focus loop** is the core architectural pattern driving all creative output.

## Understanding the Diverge Phase

The **Diverge phase** generates *N* parallel idea branches, each operating under a distinct cognitive **frame** defined in [`src/frames.ts`](https://github.com/UditAkhourii/adhd/blob/main/src/frames.ts). The system enters "ADHD-mode"—no criticism, no cross-talk, pure lateral exploration.

The phase executes through four sequential steps implemented in [`src/engine.ts`](https://github.com/UditAkhourii/adhd/blob/main/src/engine.ts)【/cache/repos/github.com/UditAkhourii/adhd/main/src/engine.ts#L2-L15】:

- **`divergeBranch`** — generates raw ideas per frame using the `DIVERGE_SYSTEM` prompt
- **`scoreIdeas`** — evaluates every leaf on **novelty**, **viability**, and **fit** via `SCORE_SYSTEM`
- **`clusterIdeas`** — groups scored ideas by underlying conceptual angle using `CLUSTER_SYSTEM`
- **Prune** — selects top-K candidates for the Focus phase

### Key Implementation Detail

The `DIVERGE_SYSTEM` prompt explicitly forbids convergence. Ideas are generated in isolation across frames, ensuring maximum coverage of the problem space before any judgment occurs.

## Understanding the Focus Phase

The **Focus phase** transforms a selected idea into concrete actionable depth. Implemented by `DEEPEN_SYSTEM` in [`src/engine.ts`](https://github.com/UditAkhourii/adhd/blob/main/src/engine.ts)【/cache/repos/github.com/UditAkhourii/adhd/main/src/engine.ts#L15-L21】, this phase "connects the dots" on a single promising leaf.

Each Focus pass produces four outputs:

1. **Sketch** — a concrete mini-design showing how the idea works
2. **Load-bearing risk** — the single most critical failure point
3. **First step** — the immediate actionable implementation move
4. **Sub-ideas** — 3-5 variations or downstream explorations

### Critical Architectural Constraint

The two phases **never intermix**. Convergence happens only after divergence completes. This strict separation prevents premature optimization from killing nascent ideas.

## Loop Continuation and Recursion

After Focus completes, the generated **sub-ideas** feed back into a new **Diverge** phase. This creates recursive expansion until termination:

- **Depth limit** — configurable recursion ceiling (default: `maxDepth`)
- **Quality threshold** — satisfaction-based early stopping
- **Budget exhaustion** — token or API call limits

The loop structure:

```

[DIVERGE] → generate wide ideas
    ↓
[SCORE] → evaluate leaves
    ↓
[CLUSTER] → group by angle
    ↓
[PRUNE] → keep top-K
    ↓
[FOCUS] → deepen selected idea
    ↺ (restart on sub-ideas)

```

## Running the Full ADHD Loop

The `run` function in [`src/index.ts`](https://github.com/UditAkhourii/adhd/blob/main/src/index.ts) orchestrates the complete two-phase loop with minimal configuration:

```typescript
import { run } from "adhd";

const problem = "Create a lightweight note-taking app that works offline.";
const options = {
  ideasPerFrame: 4,      // ideas generated per cognitive frame
  maxDepth: 2,           // recursion depth for focus passes
  model: "gpt-4o-mini",  // LLM for all phases
};

run(problem, options)
  .then((result) => {
    console.log("Best idea:", result.bestIdea.text);
    console.log("Full tree:", JSON.stringify(result.tree, null, 2));
  })
  .catch(console.error);

```

## Manual Phase Control

For custom pipelines, import individual phase functions from [`src/engine.ts`](https://github.com/UditAkhourii/adhd/blob/main/src/engine.ts):

```typescript
import {
  reframeProblem,
  divergeBranch,
  scoreIdeas,
  clusterIdeas,
  deepenIdea,
} from "adhd/src/engine";

// Optional: reframe the problem for new angles
const { reframed } = await reframeProblem(problem, undefined, undefined);

// 1. DIVERGE — generate under each frame
const frames = await selectFrames(reframed, undefined);
const branches = await Promise.all(
  frames.map((f) => divergeBranch(reframed, undefined, f, 5, undefined))
);

// 2. SCORE — evaluate all ideas
const allIdeas = branches.flatMap((b) => b.ideas);
const scores = await scoreIdeas(reframed, allIdeas, undefined);

// 3. CLUSTER & PRUNE — group and filter
const clusters = clusterIdeas(scores);
const topIdeas = pruneClusters(clusters, 10);

// 4. FOCUS — deepen the winner
const focusResult = await deepenIdea(topIdeas[0], undefined);
console.log(focusResult);

```

## Key Source Files

| File | Role |
|------|------|
| [`src/engine.ts`](https://github.com/UditAkhourii/adhd/blob/main/src/engine.ts) | Core loop implementation, system prompts (`DIVERGE_SYSTEM`, `DEEPEN_SYSTEM`, `SCORE_SYSTEM`, `CLUSTER_SYSTEM`) |
| [`src/frames.ts`](https://github.com/UditAkhourii/adhd/blob/main/src/frames.ts) | Cognitive frame definitions for Diverge phase diversity |
| [`src/render.ts`](https://github.com/UditAkhourii/adhd/blob/main/src/render.ts) | Human-readable output formatting ("Focus — deepened branches") |
| [`src/types.ts`](https://github.com/UditAkhourii/adhd/blob/main/src/types.ts) | `Idea`, `Score`, `Branch` type definitions |
| [`src/index.ts`](https://github.com/UditAkhourii/adhd/blob/main/src/index.ts) | Public API exposing `run()` |

## Summary

- **Strict phase separation** — Diverge and Focus never overlap; this protects idea diversity
- **Frame-based expansion** — Multiple cognitive angles in [`src/frames.ts`](https://github.com/UditAkhourii/adhd/blob/main/src/frames.ts) prevent local maxima
- **Scoring before clustering** — Quantitative evaluation (`novelty`, `viability`, `fit`) enables data-driven pruning
- **Recursive depth** — Sub-ideas from Focus automatically re-enter Diverge for compound exploration
- **Engine location** — All orchestration lives in [`src/engine.ts`](https://github.com/UditAkhourii/adhd/blob/main/src/engine.ts) with clear system prompt boundaries【/cache/repos/github.com/UditAkhourii/adhd/main/src/engine.ts#L2-L21】

## Frequently Asked Questions

### How does ADHD prevent premature convergence during the Diverge phase?

The `DIVERGE_SYSTEM` prompt explicitly instructs the LLM to generate ideas without criticism or cross-referencing. Each frame operates in isolation, and the `SCORE_SYSTEM` evaluation only occurs after all ideas exist. This "no judgment until divergence ends" rule is hardcoded in the phase sequence within [`src/engine.ts`](https://github.com/UditAkhourii/adhd/blob/main/src/engine.ts).

### What cognitive frames does ADHD use and where are they defined?

Frames are defined in [`src/frames.ts`](https://github.com/UditAkhourii/adhd/blob/main/src/frames.ts) and selected dynamically based on problem characteristics. Common frames include constraint inversion, first-principles decomposition, analogy transfer, and extreme user perspectives. The frame selection itself can be customized via the `selectFrames` function in the engine.

### Can I run only the Diverge or Focus phase independently?

Yes. The engine exports `divergeBranch`, `scoreIdeas`, `clusterIdeas`, and `deepenIdea` as standalone async functions. Import them directly from `adhd/src/engine` to build custom pipelines, though you must manually handle the output-to-input plumbing that `run()` automates.

### What termination conditions stop the recursive loop?

Three built-in conditions: (1) `maxDepth` recursion limit in options, (2) quality threshold satisfaction when scores plateau, and (3) implicit budget limits via token or API constraints. The loop always completes at least one full Diverge-Focus cycle before checking termination.