# How the Generator-Critic Split in ADHD Prevents Anchoring During Reasoning

> Discover how the generator-critic split in ADHD prevents anchoring bias by separating idea generation from evaluation. Learn more about the ADHD project.

- Repository: [Udit Akhouri/adhd](https://github.com/UditAkhourii/adhd)
- Tags: internals
- Published: 2026-07-30

---

**The ADHD project eliminates anchoring bias by strictly separating idea generation (divergent thinking) from idea evaluation (convergent thinking), ensuring no feedback loop exists during the initial creative phase.**

The open-source **ADHD** project (`UditAkhourii/adhd`) implements a tree-of-thought reasoning system designed to overcome cognitive biases in AI-assisted problem solving. By enforcing a hard architectural boundary between generation and criticism, the codebase prevents models from latching onto early hypotheses—known as anchoring—before exploring the full solution space.

## The Anchoring Risk in Monolithic Reasoning

When large language models evaluate their own outputs during generation, they risk anchoring to initial ideas and prematurely pruning potentially superior alternatives. Traditional single-pass prompting often mixes creative and evaluative instructions, creating a feedback loop where the model's early judgments bias subsequent outputs. The ADHD architecture solves this by physically decoupling these cognitive modes into discrete system phases.

## Phase 1: Pure Divergent Generation

The generator phase runs in **ADHD-mode**, a strictly divergent state where the model acts only as a creative engine. According to the source code in [`src/engine.ts`](https://github.com/UditAkhourii/adhd/blob/main/src/engine.ts), the `DIVERGE_SYSTEM` prompt explicitly constrains the model to raw production without judgment:

> *"Output a JSON array only… Do not evaluate, hedge, or rank. Just generate."*【/cache/repos/github.com/UditAkhourii/adhd/main/src/engine.ts#L61-L68】

This constraint appears in the `divergeBranch()` function implementation. By prohibiting evaluative language during the generation pass, the system prevents the model from forming premature conclusions about idea quality. The top-level comment in the engine file emphasizes this isolation with the directive **"no critic, no cross‑talk"**【/cache/repos/github.com/UditAkhourii/adhd/main/src/engine.ts#L4-L6】, ensuring the generator operates in a hypothesis-neutral environment.

## Phase 2: Isolated Convergent Evaluation

Only after the complete idea set materializes does the **critic phase** activate. The `scoreIdeas()` function invokes a separate system prompt (`SCORE_SYSTEM`) that evaluates each candidate on **novelty**, **viability**, and **fit**, while explicitly requesting a *"strength"* metric and an optional *"trap"* warning【/cache/repos/github.com/UditAkhourii/adhd/main/src/engine.ts#L71-L88】.

Crucially, this evaluation occurs **without cross-talk** with the generator. The critic receives the finalized batch of ideas but no internal state from the generation pass, forcing an unbiased assessment based solely on the content's intrinsic merit rather than the order or context of generation.

## Architectural Decoupling Prevents Anchoring

The anchoring effect typically arises when evaluation feeds back into generation in real-time. ADHD's architecture removes this pathway entirely:

- **Temporal separation**: Evaluation only triggers after `divergeBranch()` completes its full output batch
- **State isolation**: The critic has access to the problem context but not the generator's internal reasoning chain
- **Prompt segregation**: Distinct system prompts (`DIVERGE_SYSTEM` vs `SCORE_SYSTEM`) enforce behavioral boundaries at the instruction level

This decoupling ensures the system explores the broadest possible idea space before applying convergent filters, preventing early-generated concepts from disproportionately influencing the reasoning trajectory.

## Optional Model Decorrelation

For additional bias insulation, the CLI supports running the critic on a **different model** than the generator. The `--critic-model` flag (defined in [`src/cli.ts`](https://github.com/UditAkhourii/adhd/blob/main/src/cli.ts)【/cache/repos/github.com/UditAkhourii/adhd/main/src/cli.ts#L99-L101】) allows users to specify divergent and convergent models with potentially different training biases and failure modes:

```bash
adHD run --problem "Design a low‑latency chat service" \
          --model gpt-4o-mini \
          --critic-model gpt-4o

```

This model-level separation further decorrelates systematic biases, ensuring that even latent anchoring tendencies in the generator's architecture cannot propagate into the evaluation layer.

## Implementation Example

The following TypeScript workflow demonstrates the strict phase separation:

```typescript
// Phase 1: Pure generation – no evaluation allowed
const generatedIdeas = await divergeBranch(
  problem, 
  context, 
  frame, 
  ideasPerFrame, 
  undefined
);

// Phase 2: Separate scoring pass – no generator state access
const scoredIdeas = await scoreIdeas(
  problem, 
  generatedIdeas, 
  undefined
);

```

Each phase receives `undefined` for shared state parameters, enforcing the architectural boundary at the API level.

## Summary

- **Strict phase separation** in [`src/engine.ts`](https://github.com/UditAkhourii/adhd/blob/main/src/engine.ts) isolates generation from evaluation through distinct system prompts (`DIVERGE_SYSTEM` and `SCORE_SYSTEM`).
- **"No critic, no cross-talk"** enforcement prevents feedback loops that cause anchoring to early hypotheses.
- **Temporal decoupling** ensures the full idea space materializes before any convergent filtering occurs.
- **Optional model separation** via `--critic-model` provides additional bias decorrelation for high-stakes reasoning tasks.

## Frequently Asked Questions

### What is the generator-critic split in ADHD?

The generator-critic split is an architectural pattern in the ADHD project that divides reasoning into two isolated phases: a **generator** that produces ideas using the `DIVERGE_SYSTEM` prompt (prohibiting evaluation), and a **critic** that scores those ideas using the `SCORE_SYSTEM` prompt. This separation prevents the model from judging its own output during the creative phase, eliminating anchoring bias according to the implementation in [`src/engine.ts`](https://github.com/UditAkhourii/adhd/blob/main/src/engine.ts).

### How does preventing cross-talk reduce anchoring?

Cross-talk allows evaluative judgments to influence subsequent generations, causing the model to anchor to early hypotheses. By enforcing **no cross-talk** between the `divergeBranch()` and `scoreIdeas()` functions, ADHD ensures the generator explores the solution space without bias. The critic evaluates the complete, finalized batch rather than guiding generation in real-time, breaking the feedback loop that creates anchoring.

### Can I use different AI models for generation and criticism?

Yes. The CLI in [`src/cli.ts`](https://github.com/UditAkhourii/adhd/blob/main/src/cli.ts) exposes the `--critic-model` flag, allowing you to specify a different model for the scoring phase than the one used for generation. Running the critic on a separate model (e.g., using GPT-4 for evaluation and GPT-4-mini for generation) further decorrelates systematic biases and strengthens anchoring prevention.

### Where in the codebase is the "no critic" rule enforced?

The separation is enforced in [`src/engine.ts`](https://github.com/UditAkhourii/adhd/blob/main/src/engine.ts) through distinct system prompt constants. Lines 61-68 define the `DIVERGE_SYSTEM` prompt that explicitly prohibits evaluation, while lines 4-6 contain a top-level comment documenting the **"no critic, no cross-talk"** architectural principle. The function signatures of `divergeBranch()` and `scoreIdeas()` further enforce this by not sharing internal state between phases.