Does the trending Claude Code skill “ADHD” actually make the agent smarter? A measured duel vs single-shot

Hi, this is Shichinomiya-san (@shichinomiya_s).

Last time I measured Headroom, which claims “95% token reduction”. This time I tested ADHD, another fast-rising project on GitHub (700+ stars in ~9 days, featured by The New Stack) — a skill for Claude Code / Codex. You type /adhd "problem" and the agent fans out ideas in parallel under several different viewpoints, then critiques and prunes them. The author claims “2.9× novelty and 5.2× trap detection” over a single-shot answer.

Here’s the bottom line: it really does get smarter (broader, more novel) — but not for free. In my own runs, blind scoring picked ADHD as more useful on both problems, with the biggest gains in novelty and trap detection. The cost, though, was ~2.3× the time and ~1.9× the output — and just a few runs hit my Claude usage limit. The “5–10× cost” is no exaggeration. Here’s the honest review.

What is ADHD — getting past “the first three answers”

With linear Chain-of-Thought, an LLM anchors on whatever it says first. Tree-of-Thought branches out but still walks a shared context, so the anchoring persists across branches. ADHD treats this as an architectural problem, not a prompting one:

• Divergence — spawn N isolated processes under deliberately distorted “cognitive frames” (regulator, biology, speedrunner, 10-year-old, $0 budget…), with zero shared context between branches.
• Focus — a separate critic pass scores and clusters the ideas, prunes traps (seductive-but-flawed approaches), and deepens the survivors.

It’s aimed at “give me a few ways to…” problems: design, naming, API surface, fuzzy debugging. The skill itself says to skip it for syntax, lookups, and closed/standard questions.

Setup and method

Two problems. P1: design an API rate limiter for a multi-tenant SaaS (a few approaches). P2: investigate intermittent production 504 timeouts (~once/hour, no clear pattern) — the “fuzzy debugging” ADHD claims to be good at.

To avoid bias, quality was scored blind by a separate claude call — which one was ADHD was hidden, and the A/B positions were swapped between problems.

npx skills add UditAkhourii/adhd
# baseline
claude -p "<problem; give a few options>"
# ADHD
claude -p "Use the adhd skill on this problem: <same problem>"

Result 1: Quality — ADHD won both, blind

The blind judge picked ADHD as “more useful overall” on both problems. The biggest gains were novelty (+4.5) and trap detection (+4.0) — matching the direction of the author’s claims. Only actionability slightly favored baseline: textbook answers are concrete and immediately implementable.

Result 2: Cost — 2.3× time, 1.9× output, and a usage cap

ADHD makes ~10 internal agent calls, so time and tokens both balloon. In fact, just a few runs hit my Claude subscription’s session limit, forcing a wait. The skill’s self-declared “5–10× a single answer” held true in both feel and numbers.

Discussion — what was actually “working”

The biggest difference was in the substance. On P1, baseline gave the textbook four (Redis token bucket / local memory + consistent hashing, etc.). ADHD instead generated 30 ideas across 5 frames, then surfaced non-obvious options you rarely get single-shot — e.g. “nodes lease a slice of a central budget, and the hot path enforces with GCRA and zero network calls,” weighted fair scheduling (WDRR) that treats the problem as scheduling rather than metering, and even capacity futures — each with its load-bearing risk spelled out.

So ADHD’s value isn’t “get the right answer faster” — it’s “surface the angles you wouldn’t have thought of, traps and all.” A strong sparring partner for ideation. A believable result.

Who it’s for / caveats

Good fit for:

• Open-ended problems (design, naming, API surface, strategy) where you want to widen the option space
• Pressure-testing whether you’re anchored on your own first idea
• Anyone already on Claude Code / Codex who can just add a skill

Caveats:

• The cost is real: ~2.3× time, ~1.9× output, and it burns through your quota fast (I hit the cap in a few runs)
• Overkill for syntax / boilerplate / closed problems (the skill itself says “don’t”)
• These quality scores are a blind LLM-as-judge — subjective, and unlike the objective time/size numbers. Small sample (2 problems)
• The author’s “5.2×” etc. are from the author’s own tasks; my different tasks/scoring show the same direction but smaller magnitude

Summary

Conclusions from actually dueling the trending ADHD skill against single-shot in Claude Code (all measured):

• ADHD won both problems blind, especially novelty 4.5→9.0 and trap detection 5.0→9.0
• Its strength is non-obvious options and trap-spotting; baseline narrowly leads on actionability
• Cost is 2.26× time, 1.93× output, and it hit my usage cap in a few runs
• Verdict: worth it as a sparring partner for open-ended design/ideation; overkill for routine work

If you know you tend to “settle for the first three ideas,” it’s worth running once before a design decision — but aim it at the questions that matter, for cost’s sake.

Related reading

More on AI and Claude Code:

• Is Headroom’s “95% token reduction” for real? I measured it
• The Definitive Claude Code Getting-Started Guide

Verification note (for reproduction)

All numbers are measured on the author’s M1 Max (64GB).

Environment: Apple M1 Max / 64GB / claude CLI 2.1.161 (Claude Code, subscription auth) / adhd-agent 0.1.4

# install skill
npx skills add UditAkhourii/adhd

# run baseline vs ADHD on the same problem (timed)
/usr/bin/time -p claude -p "<problem>"
/usr/bin/time -p claude -p "Use the adhd skill on this problem: <problem>" --permission-mode bypassPermissions

# quality scored blind by a separate claude call (A/B hidden, positions swapped)

Measured: wall time baseline 95.4s / ADHD 216.1s (2.26×); output 5,623 / 10,697 chars (1.93×); blind scores (1-10, avg of 2) breadth 7.0→9.0, novelty 4.5→9.0, trap detection 5.0→9.0, actionability 8.5→8.0; ADHD won 2/2.

Known limitations: quality is an LLM-as-judge score (subjective); only 2 problems (small sample). ADHD hit my Claude session cap after a few runs, so the sample was kept small (the cost itself being a finding). The author’s published figures (2.9× novelty, 5.2× trap detection) are from the author’s own 6 tasks, different from this test.