5 Claude Code Skills Every ADHD Developer Needs

I have built 114 Claude Code skills. Most of them are engineering plumbing. But five of them exist for one reason only: my executive function has specific, repeatable holes, and I got tired of falling into the same ones. These five are not productivity hacks. Each one maps to a named ADHD deficit, and each one fills it the same way every time so I do not have to re-improvise around my own brain at 2pm.

If you want the broader system this sits inside, start with my Claude Code ADHD workflow and the CLAUDE.md guide. This post is the skills layer specifically.

What Is a Claude Code Skill?

A skill is a named, repeatable workflow you invoke with a slash command. Instead of re-prompting Claude Code from a blank slate every time (“okay, help me figure out what to work on, here is my situation again…”), you type /adhd-task-triage and it runs the same defined steps it ran yesterday. For an ADHD brain, that determinism is the feature. The skill does not depend on me remembering how to drive it. It just runs.

Custom skills live in a .claude/skills/<name>/SKILL.md file that describes what the skill does and when it should fire. You can build one for any gap you fall into more than twice.

1. adhd-task-triage: Energy-Based Prioritization

The gap it fills: task initiation paralysis.

Standard task managers sort by priority or deadline. That assumes you can act on the top item by willpower. ADHD does not work that way. The top-priority task and the task you can actually start right now are often different tasks, and trying to force the high-priority one when your initiation circuit is offline produces zero output and a guilt spiral.

adhd-task-triage sorts by available energy, not importance. You tell it where you are (wired, foggy, depleted), it looks at the work in front of you, and it hands back the task that matches the state you are actually in, not the one you wish you were in.

/adhd-task-triage

Why it helps specifically: it removes the moral framing. The question stops being “why can’t you just do the important one” and becomes “what can this brain, in this state, actually initiate.” Matching the task to the energy is how you get momentum, and momentum is the thing ADHD brains can ride once it exists.

2. mirror: The Counter to Discounting the Positive

The gap it fills: cognitive distortion, specifically discounting the positive.

“Discounting the positive” is a CBT term for a thinking pattern where you mentally delete your own wins. You shipped three features, but your brain only renders the one bug. ADHD comes bundled with this so often that it feels like just being realistic. It is not realistic. It is a measurement error, and it is corrosive, because a brain that cannot see its own progress loses the dopamine that progress is supposed to pay out.

mirror reflects back what I actually did, grounded in evidence, not vibes. It reads the session, the commits, the closed tasks, and tells me plainly: here is what shipped. Not cheerleading. Receipts.

/mirror

Why it helps specifically: ADHD reward systems are under-fueled, and discounting the positive starves them further. When the skill says “you closed four tasks and shipped the auth flow,” and points at the commits, the distortion has nothing to push against. I cannot argue with the log. The win gets to count, which is the entire point.

3. pickup: Session Resume for Context-Switching

The gap it fills: context-switch recovery cost.

Every interruption tears down the mental model of what I was doing. Rebuilding it is the 23-minute reconstruction tax that, for an ADHD brain, runs longer and hits more often. The worst version is the overnight gap: I close the laptop mid-thought and the next morning the entire working model is just gone.

pickup reconstructs the session for me. It reads where I left off, what was in flight, what was blocked, and summarizes the open state before I write a single line.

/pickup

Why it helps specifically: it converts a cold start into a warm one. The reconstruction that used to eat the first half hour of every session, the part where I open files semi-randomly trying to jog the memory, gets done by the skill in seconds. I am not rebuilding the model. I am reading it back.

4. schedule: A Patch for Time Blindness

The gap it fills: time perception distortion.

Time blindness is an ADHD hallmark: you cannot feel time passing, so “I’ll just fix one thing” becomes a four-hour rabbit hole, and a two-hour task gets estimated at twenty minutes. You ship on deadline panic because your brain has no internal clock to pace against.

schedule puts external markers on the work: it sets up recurring checkpoints and time-boxed runs so the passage of time becomes visible instead of imagined. It is the external clock my brain does not have.

/schedule

Why it helps specifically: ADHD does not respond well to “be more aware of time,” because the awareness machinery is the thing that does not work. It responds to external structure. A skill that interrupts at a real interval and asks “you set 45 minutes for this, you are at 60, still the right task?” gives me the time signal my brain cannot generate, at the moment the drift is happening rather than after.

5. librarian: Reducing the Cognitive Load of Navigation

The gap it fills: working-memory overload from holding a whole codebase in your head.

Navigating a large codebase means holding a map of it in working memory: where things are, what calls what, which file owns which concern. ADHD working memory cannot hold that map, so every navigation becomes a fresh, expensive search, and the expense itself becomes a reason to avoid touching unfamiliar parts of the code.

librarian walks the knowledge layer for me. Instead of me grepping around trying to reconstruct where a behavior lives, I describe what I am after and it returns the relevant pieces and how they connect. It holds the map so I do not have to.

/librarian

Why it helps specifically: it collapses the navigation tax. The mental energy I would spend reconstructing “where does this live and what touches it” is exactly the executive-function budget I do not have to spare. Offloading the map means I can spend that budget on the actual change instead of on finding the place to make it.

What This Looks Like in Practice

A real morning, lightly compressed, showing the five working as a chain rather than in isolation:

9:10  Sit down. No memory of yesterday's state.
      /pickup  ->  "You were mid-refactor on the signal loop, JWT
                    middleware blocked on a cookie setting. 2 tasks open."
      Cold start avoided. ~20 min reconstruction skipped.

9:14  Brain is foggy, not wired.
      /adhd-task-triage  ->  hands me the low-initiation-cost task
                            (write the middleware test), not the hard one.
      Momentum started instead of staring at the blank editor.

9:20  Need to change the auth schema but forget where it lives.
      /librarian  ->  returns the schema file + everything that touches it.
      Navigation tax collapsed. No grep spiral.

9:25  /schedule already running a 45-min checkpoint in the background.
      At 10:10 it pings: "60 min on a 45 task, still the right one?"
      Caught a hyperfocus drift before it ate the morning.

11:30 Brain says "you got nothing done."
      /mirror  ->  "3 tasks closed, middleware shipped, schema migrated.
                    Here are the commits."
      Distortion loses. The win counts.

None of these is doing anything a disciplined neurotypical developer could not do by hand. That is the point. They do it for me, the same way every time, so the doing does not depend on executive function I cannot summon on command.

How Do You Start Building Your Own?

Do not install five skills today. Pick the one deficit that costs you the most, mine was the cold-start reconstruction, and build or invoke the one skill that targets it. A skill is a SKILL.md file in .claude/skills/ that names what it does and when it triggers. Start there, use it for a week, and let the next-most-expensive gap tell you what to build next.

The pattern underneath all five is the same: name the executive-function gap precisely, then build a repeatable thing that fills it so you stop re-improvising around your own brain.

Frequently Asked Questions

What is a Claude Code skill? A packaged capability you invoke by name (like /pickup) that runs a defined, repeatable workflow. Instead of re-prompting Claude from scratch each time, you call the skill and it runs the same proven steps every time.

Are these built into Claude Code? Claude Code ships with a skill system and some bundled skills. Several here (like adhd-task-triage and mirror) are custom skills I built for my own setup. The transferable thing is the pattern: build a skill for any recurring executive-function gap.

Do I need ADHD for these to help? No. They help anyone who context-switches a lot, undersells their progress, or loses the thread between sessions. ADHD just makes the gaps sharper, so the payoff comes faster.

How do I invoke a skill? Type its slash command (for example /pickup) in Claude Code. Custom skills live in .claude/skills/ as a SKILL.md file that defines what the skill does and when it fires.

These skills are the executive-function layer on top of the working-memory layer from the CLAUDE.md guide. For the clinical picture of why each gap exists and how AI compensates, read how I use AI as an executive function prosthetic.