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

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 at line 218, where the three metrics are combined using fixed decimal weights:

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:

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

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

// 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 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 (type definitions) and 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.

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 at line 218 within the total score calculation. Type definitions for the score components exist in src/types.ts, while the design rationale and weight explanations are documented in documentation/how-it-works.md according to the repository source.

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