# Why nonObviousPick Prioritizes Novelty Over Total Score in the ADHD Engine

> Discover why nonObviousPick prioritizes novelty over total score in the ADHD engine. Learn about its unique two-step ranking strategy that highlights the most novel viable candidate.

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

---

**The `nonObviousPick` prioritizes novelty over total score because the ADHD engine applies a two-step ranking strategy that first filters ideas by aggregate quality and then highlights the most novel viable candidate from the shortlist.**

The `nonObviousPick` function is a core feature of the ADHD tree-of-thought engine in the `UditAkhourii/adhd` repository, designed to surface ideas that are both credible and surprising. If you have wondered why `nonObviousPick` prioritizes novelty over total score instead of simply returning the highest-ranked idea, the answer lies in a deliberate divergence-convergence pipeline. Understanding this design reveals how the engine balances viability with unexpected solutions.

## How the ADHD Engine Filters Ideas by Total Score

Before `nonObviousPick` is ever calculated, the engine evaluates every generated idea through a scoring phase. Each idea receives a **total** value that weights novelty, viability, and fit, as defined by the `Score` type in [`src/types.ts`](https://github.com/UditAkhourii/adhd/blob/main/src/types.ts) near lines 16-18. The engine sorts all ideas by this aggregate score and retains only the top performers in a shortlist.

According to the source code, the `Score.total` field aggregates the individual dimensions to create an overall quality gate. This initial filter guarantees that only ideas strong across all metrics—high viability, strong fit, and meaningful novelty—advance to the next stage. You can see this scoring contract established at the top of [`src/types.ts`](https://github.com/UditAkhourii/adhd/blob/main/src/types.ts).

## How nonObviousPick Selects the Most Novel Viable Idea

Once the shortlist is locked, the engine shifts from filtering to highlighting. Rather than returning the idea with the highest total score from the shortlist, `nonObviousPick` applies a secondary ranking that intentionally weights novelty most heavily.

### The Novelty-Weighted Formula in src/engine.ts

The selection logic lives in [`src/engine.ts`](https://github.com/UditAkhourii/adhd/blob/main/src/engine.ts) at lines 88-95, where the shortlist is re-sorted using the expression `b.score!.novelty + b.score!.viability * 0.5`. The idea that ranks first after this sort becomes `nonObviousPick`. This calculation explicitly favors novelty while still rewarding viability through the `0.5 × viability` term. As implemented in `UditAkhourii/adhd`, this means an idea with exceptional novelty can win even if its total score is not the absolute highest in the shortlist, provided it clears the initial quality threshold.

### The "Non-Obvious-but-Viable" Design Goal

This behavior is intentional and documented in the engine’s comment header in [`src/engine.ts`](https://github.com/UditAkhourii/adhd/blob/main/src/engine.ts) around lines 8-11. The design reflects a "non-obvious-but-viable" goal: the final recommendation must be practical enough to implement, yet distinct enough to avoid obvious or generic solutions. By splitting the process into a total-score filter followed by a novelty-centric selector, the engine ensures the pick is both **credible** and **surprising**.

## Practical Example: Running the ADHD Engine

You can observe this two-stage behavior by calling the `run` entry point from [`src/index.js`](https://github.com/UditAkhourii/adhd/blob/main/src/index.js). The returned object contains both the `shortlist` (ranked by total score) and the `nonObviousPick` (chosen by the novelty-weighted rule).

```typescript
import { run } from "./src/index.js";

(async () => {
  const result = await run({
    problem: "How can we improve remote team collaboration?",
    ideasPerFrame: 4,
    topK: 3,
  });

  // Top ideas filtered by total score
  console.log("Shortlisted ideas:", result.shortlist);

  // Final pick: highest novelty among viable ideas
  const pick = result.nonObviousPick;
  if (pick) {
    console.log("🌟 Non-obvious pick →", pick.text);
    console.log("   Novelty:", pick.score?.novelty);
    console.log("   Viability:", pick.score?.viability);
    console.log("   Total:", pick.score?.total);
  } else {
    console.log("No viable non-obvious idea found.");
  }
})();

```

In this snippet, `result.shortlist` surfaces the strongest overall ideas according to `Score.total`, while `result.nonObviousPick` returns the idea selected by the novelty-centric formula in [`src/engine.ts`](https://github.com/UditAkhourii/adhd/blob/main/src/engine.ts). The console output often reveals a pick whose novelty score exceeds that of the top shortlist entry, demonstrating why `nonObviousPick` prioritizes novelty over total score in the final recommendation.

## Summary

- The ADHD engine first **filters** ideas using `Score.total` in [`src/types.ts`](https://github.com/UditAkhourii/adhd/blob/main/src/types.ts), ensuring only high-quality candidates reach the shortlist.
- The `nonObviousPick` then **re-ranks** that shortlist in [`src/engine.ts`](https://github.com/UditAkhourii/adhd/blob/main/src/engine.ts) (lines 88-95) using `novelty + 0.5 × viability`.
- This two-step approach guarantees the final pick is **viable enough to be useful** but **novel enough to be non-obvious**.
- The design intent is explicitly documented in the comment header of [`src/engine.ts`](https://github.com/UditAkhourii/adhd/blob/main/src/engine.ts) (lines 8-11).

## Frequently Asked Questions

### What is the difference between shortlist and nonObviousPick in ADHD?

The `shortlist` contains the top ideas ranked by aggregate `Score.total` in [`src/types.ts`](https://github.com/UditAkhourii/adhd/blob/main/src/types.ts), representing the strongest overall candidates across novelty, viability, and fit. The `nonObviousPick` is a single idea drawn from that shortlist using the secondary novelty-weighted sort in [`src/engine.ts`](https://github.com/UditAkhourii/adhd/blob/main/src/engine.ts) (lines 88-95). Together, they represent the filter stage and the highlight stage of the engine pipeline.

### Why doesn't nonObviousPick simply choose the highest total score?

Choosing the highest total score would return the safest, most balanced idea, which is often the most obvious one. By weighting novelty more heavily after the initial quality filter, `nonObviousPick` fulfills the engine’s documented design goal of recommending solutions that are credible but unexpected. This is why the final selection step deliberately deprioritizes the total score in favor of standout novelty.

### How does the ADHD engine calculate the total score for ideas?

The total score is defined in [`src/types.ts`](https://github.com/UditAkhourii/adhd/blob/main/src/types.ts) as an aggregated value combining novelty, viability, and fit. During the scoring phase, each idea is evaluated across these dimensions, and the composite total determines whether an idea qualifies for the shortlist. It acts as a quality gate before the novelty-centric `nonObviousPick` selection occurs.

### Can I adjust the weight given to viability in nonObviousPick?

The current weighting is hardcoded in [`src/engine.ts`](https://github.com/UditAkhourii/adhd/blob/main/src/engine.ts) as `b.score!.novelty + b.score!.viability * 0.5`. To change how much viability influences the final pick, you would need to modify the sort expression in that file and rebuild the pipeline. There is no external configuration flag exposed in [`src/cli.ts`](https://github.com/UditAkhourii/adhd/blob/main/src/cli.ts) or the entry point to adjust this ratio at runtime.