# ADHD Scoring Weights Explained: How Ideas Are Ranked and Why Novelty Gets 35%

> Discover ADHD scoring weights: learn how novelty is 35%, viability 40%, and fit 25% to prioritize creative yet practical solutions. Understand idea ranking.

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

---

**ADHD applies fixed scoring weights of 35% for novelty, 40% for viability, and 25% for fit to evaluate generated ideas, deliberately setting novelty at 35% to prioritize creative solutions that escape obvious defaults without sacrificing practicality.**

The ADHD repository (UditAkhourii/adhd) implements a structured evaluation framework for generated ideas—referred to as "leaves"—that assigns specific scoring weights to three independent dimensions. This weighting system, hardcoded in the engine logic, ensures that the most interesting suggestions balance creativity with real-world applicability. Understanding these ADHD scoring weights reveals how the system surfaces non-obvious yet actionable solutions from generated candidates.

## The Three Scoring Metrics

ADHD evaluates every leaf on a 0–10 scale across three distinct dimensions.

### Novelty

**Novelty** measures how far an idea deviates from the obvious default solution. A score of 10 represents a completely unexpected approach, while 0 indicates the most conventional path.

### Viability

**Viability** assesses how practical and feasible the idea is within the given context. This metric ensures that highly creative suggestions remain grounded in implementation reality.

### Fit

**Fit** evaluates how well the idea aligns with the original problem statement. Even novel and viable ideas receive lower scores if they diverge from the core requirements.

## How ADHD Calculates Total Scores

The total score computation occurs in [`src/engine.ts`](https://github.com/UditAkhourii/adhd/blob/main/src/engine.ts) at line 218, where the three metrics are combined using fixed decimal weights:

```ts
const total = r.novelty * 0.35 + r.viability * 0.4 + r.fit * 0.25;

```

This implementation produces the following **ADHD scoring weights**:

- **Novelty**: 35% (multiplier 0.35)
- **Viability**: 40% (multiplier 0.4)
- **Fit**: 25% (multiplier 0.25)

Each metric contributes proportionally to the final score, with viability receiving the highest individual weight to ensure practicality remains the primary constraint.

## Why Novelty Is Weighted at 35%

The **35% novelty weight** is deliberately chosen to support ADHD's core mission of "escaping the obvious." At exactly 35%, novelty carries substantial influence—enough to elevate creative, non-standard solutions above conventional ones—but stops short of dominating the evaluation. This specific percentage ensures that purely "weird" ideas cannot win based on novelty alone; they must also demonstrate reasonable viability (40%) and problem alignment (25%). The balance prevents the system from selecting interesting but unactionable suggestions, while still rewarding candidates that break away from default thinking.

## Implementing the Scoring Algorithm

You can reproduce the ADHD scoring logic using TypeScript. First, define a leaf's raw scores on the 0–10 scale:

```ts
// 1️⃣ Define a leaf’s raw scores (0‑10 each)
const leafScore = {
  novelty: 8,   // non‑obvious
  viability: 6, // practical
  fit: 7,       // matches problem
};

```

Then apply the same weighting calculation used in [`src/engine.ts`](https://github.com/UditAkhourii/adhd/blob/main/src/engine.ts):

```ts
// 2️⃣ Compute the weighted total (same logic as src/engine.ts)
function computeTotal(s: {novelty: number; viability: number; fit: number}) {
  return s.novelty * 0.35 + s.viability * 0.4 + s.fit * 0.25;
}

const totalScore = computeTotal(leafScore);
console.log(`Total score: ${totalScore.toFixed(2)}`); // → Total score: 6.80

```

### Retrieving the Non-Obvious Pick

To surface the highest-novelty viable leaf—ADHD's "non-obvious pick"—filter for viable candidates then compare their weighted novelty:

```ts
// Assuming `leaves` is an array of scored leaves
const viable = leaves.filter(l => l.score!.viability > 0);
const nonObviousPick = viable.reduce((a, b) =>
  (b.score!.novelty + b.score!.viability * 0.5) -
  (a.score!.novelty + a.score!.viability * 0.5) > 0 ? b : a);

```

## Summary

- **ADHD scoring weights** assign 35% to novelty, 40% to viability, and 25% to fit, as implemented in [`src/engine.ts`](https://github.com/UditAkhourii/adhd/blob/main/src/engine.ts) line 218.
- The **35% novelty weight** specifically balances creative exploration against practical constraints, preventing dominance by either conventional or impractical ideas.
- All three metrics use a **0–10 scale**, allowing straightforward comparison and weighted summation.
- The system prioritizes **viable creativity**—ideas must score reasonably across all three dimensions to rank highly.
- Source definitions reside in [`src/types.ts`](https://github.com/UditAkhourii/adhd/blob/main/src/types.ts) (type definitions) and [`documentation/how-it-works.md`](https://github.com/UditAkhourii/adhd/blob/main/documentation/how-it-works.md) (design rationale).

## Frequently Asked Questions

### What are the exact ADHD scoring weights used in the algorithm?

The algorithm uses fixed weights of 35% for novelty, 40% for viability, and 25% for fit. These values are hardcoded as decimal multipliers (0.35, 0.4, and 0.25) in the total score calculation within [`src/engine.ts`](https://github.com/UditAkhourii/adhd/blob/main/src/engine.ts).

### Why is novelty weighted at 35% instead of a higher percentage?

Novelty stops at 35% to ensure it never outweighs viability (40%). This prevents the system from selecting purely eccentric ideas that cannot be implemented, while still giving creative solutions enough weight to outrank obvious but viable alternatives.

### How does the ADHD scoring system balance creativity against practicality?

By weighting viability at 40%—the highest single weight—ADHD ensures that practicality remains the primary gate. Novelty (35%) can elevate creative solutions, but only if they meet minimum viability thresholds. The fit metric (25%) further ensures alignment with original requirements, creating a three-way balance between innovation, execution, and relevance.

### Where in the codebase are these scoring weights defined?

The weights appear in [`src/engine.ts`](https://github.com/UditAkhourii/adhd/blob/main/src/engine.ts) at line 218 within the total score calculation. Type definitions for the score components exist in [`src/types.ts`](https://github.com/UditAkhourii/adhd/blob/main/src/types.ts), while the design rationale and weight explanations are documented in [`documentation/how-it-works.md`](https://github.com/UditAkhourii/adhd/blob/main/documentation/how-it-works.md) according to the repository source.