How ADHD Helps in Agentic Coding

I have ADHD. For 20 years that meant 20 years of dead side projects. For the last six months, adhd coding with parallel agents has flipped that loop on its head, and I now ship more than most senior devs I know.

This is not a brag. It is a claim I would have laughed at in 2024. The thing that changed is not me. The thing that changed is the shape of the workflow. Adhd coding used to mean "fight your own brain for a long, lonely block of focus." Adhd coding today means "fan out small tasks, pin context to disk, let the harness ping you when something needs a decision." That is a different job, and it is a job my brain is exxtremaly good at.

Why traditional dev workflow punishes ADHD

A traditional coding day is one human, one editor, one task, four to eight hours. Re-loading the mental model of a codebase after a 30-minute interruption is brutal. The reward shows up at the end — sometimes days later, when the feature ships.

That shape is the worst possible shape for ADHD. My attention is task-novelty-driven, not duration-driven. I get a clean burst of 25 to 45 minutes, then the novelty drops and I am done. For two decades I realyzed I was the bottleneck on every solo project I started, and the reason was the same — the workflow demanded a kind of attention I do not produce.

Before we go further, here are the five terms this article keeps coming back to.

ADHD

Attention Deficit Hyperactivity Disorder — a neurotype where attention is task-novelty-driven, not duration-driven. Short bursts come easy. Long uninterrupted blocks do not.

A Claude Code slash-command that runs the same prompt on a recurring interval. Useful for "check the test suite every five minutes until it passes."

A Claude Code primitive for scheduling a future wake-up. The harness pings you (or itself) at a chosen time with a pre-written prompt.

A Claude Code skill for fan-out work. You hand it a list of independent tasks; it spawns one subagent per task and returns the merged result.

CLI

Command-Line Interface — the terminal-based program that runs Claude Code locally on your machine.

Short bursts plus parallel agents — the adhd coding loop

Here is the actual loop I run on a normal weekday. This is the heart of how adhd coding now works for me.

1. 01

   Write the spec

   Write a one-paragraph spec for the next slice of work. Plain English. What changes, why, and what "done" looks like.

2. 02

   Fan out to parallel agents

   Hand the spec to superpowers:dispatching-parallel-agents with a list of three to six independent subtasks.

3. 03

   Step away

   Step away for 15 to 25 minutes. Make coffee. Walk. Reply to a message.

4. 04

   Read the merged diff

   Come back to a merged result. Read the diff. Approve, reject, or revise.

5. 05

   Loop

   If revise: write the next one-paragraph spec. Loop.

That loop matches the way my brain produces attention. The novelty is fresh every cycle — a new spec, a new diff to read, a new decision. The hard part of adhd coding (sustaining a four-hour mental model of the whole codebase) is gone, because the agents are holding most of the model on disk for me. I just steer.

Two things make this work. The first is that the agents follow my instructions LITERALLY. If I say "do not touch the auth layer," they do not touch the auth layer. The second is that they default to ADDITIVE behavior — they add code rather than rewriting it — which according to the Anthropic SDK documentation is the documented behavior pattern for a Claude agent given an under-specified task. The agents pattern-match against training data; they do not model author intent. That is a feature for me. It means the surprises stay small.

$ claude /loop 5m "run npm test, paste failing test names"
$ claude superpowers:dispatching-parallel-agents \
    --task "extract billing helpers" \
    --task "add zod schema for invoice" \
    --task "write 3 vitest cases for invoice"

Externalized memory — HANDOFF.md, FILE_MAP, AGENT-CONTEXT-MAP

The second piece of the adhd coding workflow is externalized memory. My working memory is short. The codebase's working memory does not need to be.

Three files do most of the work. HANDOFF.md is a one-page state-of-the-system note I update at the end of every session — what I just changed, what is half-done, what the next session should pick up first. FILE_MAP.md lists every load-bearing module and what it owns, so an agent (or a returning me) does not have to grep the tree to find the auth layer. AGENT-CONTEXT-MAP.md is a routing table — "if the user asks for X, the relevant files are A, B, C."

These files do for adhd coding what a Post-it note covered desk does for an offline ADHD brain. The state is not in my head. The state is on disk. When I pick up the project at 9 a.m. on Monday after a weekend away, I do not have to reconstruct anything — I read three short pages, and I am back in the model.

Schedule-wakeup loops so the harness pings YOU

This is the part of adhd coding that surprised me the most. I expected to be the one driving the agent. It turns out the harness is much better at driving me.

The pattern looks like this: I kick off a long-running task — say, a 12-minute build — and instead of staring at the terminal, I tell Claude Code to wake itself up in 15 minutes via the schedule primitive. When the timer fires, the harness checks the build, summarizes the result, and pings me only if a decision is needed. If everything passed, I find out the next time I open the terminal.

The harness is a patient roommate. It does not get bored. It does not lose interest. It just waits, checks, and tells me what changed. That is the partner an ADHD brain has wanted for 20 years.

I run three or four of these wake-up loops at any given time. Test suites. Deploy checks. A nightly drift-guard sweep at 4 a.m. None of them require my attention until something is genuinely off. Adhd coding stops feeling like "fight your brain" and starts feeling like "supervise four assistants who never need a meeting."

$ claude schedule \
    --in 15m \
    --prompt "check build at logs/build.txt; ping me only if FAIL"

What still doesn't work — the honest list

Adhd coding is not magic. There are categories of work the loop does not help with, and pretending otherwise would be unfair.

1. 01

   Novel architecture decisions

   The agents pattern-match against training data; they do not invent a new layout for me. Real architecture still happens at the whiteboard with a human collaborator.

2. 02

   Debugging a heisenbug

   When the bug only reproduces in production at 3 a.m., a parallel-agent fan-out does not help. I still have to sit with the logs.

3. 03

   Reading code I did not write at all

   If I was handed a 200,000-line legacy Java service, no amount of superpowers:dispatching-parallel-agents would replace the hours of human reading required to build the mental model.

4. 04

   Anything emotional

   The harness does not know I have been working since 6 a.m. and need to stop. Pacing is still on me.

The honest claim is narrower than "ADHD is a superpower now." The honest claim is that for the specific task of shipping product-grade TypeScript on a codebase I designed, adhd coding with parallel agents is the first workflow I have ever found that matches the shape of my attention. The other categories above are still unfortunatelly hard.

The same loop helps anyone solo on a multi-week codebase

If you do not have ADHD, the loop above is still useful. The reason is not neurology — it is information theory. A solo developer on a multi-week codebase has a memory problem too. The codebase outgrows their head by week three. Externalized memory and parallel agents do the same job for them; they just do it less urgently.

The pattern generalizes. Write the one-paragraph spec. Fan out the independent work. Pin the state to disk. Let the harness wake you when a decision is needed. The CLI does the boring waiting. You do the steering.

The difference is the slope. For a senior dev with normal executive function, this loop is a 1.3x productivity bump. For an ADHD founder who spent 20 years watching side projects die at the four-hour mark, adhd coding with this loop is the difference between shipping and not shipping.

References

• Anthropic SDK Python repository — documented agent behavior patterns: github.com/anthropics/anthropic-sdk-python
• Anthropic developer documentation — Claude Code primitives (/loop, schedule, parallel-agent dispatch): docs.anthropic.com