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

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, 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【/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:

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:

// 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 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.

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 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 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.

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