The i-have-adhd Claude Skill: Install and 3 Skills I Run

If you searched for the i-have-adhd skill, it is ayghri/i-have-adhd, an MIT-licensed Claude Code plugin that changes how Claude answers you: action first, numbered steps, no preamble. It installs with two commands, covered below. That skill fixes how Claude talks to you. It does not touch the three places ADHD costs a developer the most time, so this post also covers mirror, for reversing positive-discounting, librarian, for the working-memory cost of navigating a codebase, and standing, for the week-scale version of the same distortion. Each targets a named deficit and closes it the same way every time, so getting the work done does not depend on executive function you cannot summon on command.

Both are in a public MIT repo, copied unedited from my disk. The install is one clone and one copy, and the install page has the command, the troubleshooting, and the difference between these and the two other skills that share the name. This post is the longer explanation of what each one does and why.

Searching more broadly for Claude and ADHD? The 5-step coding workflow is the system piece, start there, and the CLAUDE.md guide covers the config layer. This post assumes you already have a workflow and want the specific tools that plug into it.

Not a developer? The same daily setup without a terminal is how to use Claude for ADHD, and the nine prompts I run inside it, each with the failure it guards, are in ADHD prompts for Claude.

The i-have-adhd Skill (Not Mine, and Worth Installing First)

If you got here by searching “i have adhd skill” or “claude i have adhd”, the thing you are looking for is ayghri/i-have-adhd, an open-source plugin by a different author. I did not write it. It had 27,119 GitHub stars and an MIT licence when I checked on 4 September 2026, and it is the most-installed ADHD skill for Claude Code by a wide margin. Here is what it does and how it differs from the two skills further down this page.

What it does. It changes how the assistant talks to you, not what it does for you. Ten rules, applied to every reply for the rest of the session: lead with the next action, number multi-step work, end with one concrete next step, suppress tangents, restate state every turn, give time estimates in minutes, make wins visible, report errors matter-of-factly, cap lists at five items, and drop preamble, recaps and closers. The author credits Ramsay and Rostain’s The Adult ADHD Tool Kit as the source of the rules, adapted for how a model should respond rather than how a person should organise a day.

Install in Claude Code (two commands, under a minute):

claude plugin marketplace add ayghri/i-have-adhd
claude plugin install i-have-adhd@i-have-adhd

Then type /i-have-adhd in any session. It stays on until you say “stop adhd mode”. For always-on behaviour, touch ~/.claude/.i-have-adhd-always installs a session-start hook so you never have to invoke it. The repo also ships installers for Codex, Cursor, Gemini CLI, OpenCode and others; see its INSTALL.md.

How it differs from mirror, librarian, and standing. i-have-adhd is an output style. It makes every answer easier for an ADHD brain to act on, and I recommend it as the first thing to install. It does not know what you shipped today and it does not hold the map of your codebase. mirror reads your git log to counter the feeling that nothing got done; librarian walks a knowledge graph so you do not have to reconstruct where behaviour lives; standing reads your transcripts and git to place a week against your own record. Run i-have-adhd for the format, then add the three below for the executive-function gaps the format cannot close.

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, I feel like nothing got done, here is my situation again…”), you type /mirror 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. 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. Before it says anything reassuring it reads the git log since the session started, the diff of uncommitted work, the decisions made in the conversation, and the dead ends ruled out. Then it 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.

It also refuses the two failure modes on either side. It does not flatter, because praise I cannot trace to an artifact gets discounted like everything else. And it does not argue with the feeling. It puts the record beside the feeling and stops. If little genuinely got done, it says so and locates the cause accurately, which is usually the plan and not the person.

2. 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 in my own words and it returns a three-line readback: what it heard, which knowledge nodes are involved, and one concrete proposal labelled Verified, Inferred or Target. It holds the map so I do not have to.

/librarian why is the startup slow?

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.

One dependency, stated plainly: librarian needs a knowledge graph to walk, a docs/codex/ directory in the repo. Without one it tells you so and steps aside. mirror works standalone from git history on any repo. Install that one first.

3. standing: The Week Against Your Own Month

The gap it fills: comparing yourself to an imagined peer who ships every day.

mirror answers “did I do anything today”. The week-scale question, “am I getting anywhere”, is the one that does the most damage, because the comparison class is usually a fictional developer who never has a slow Tuesday. standing refuses to answer that question with a feeling. The row from the repository README, quoted verbatim:

Skill	The gap it closes	Standalone?
standing	Comparing yourself to an imagined peer who ships every day. Reads your session transcripts and git, counts the invisible work, and places the week against your own trailing month, with instrument and window on every number.	Yes. Works from git and Claude Code transcripts. Field comparison needs a cited docs/standing/benchmark.md.

It reads the last few Claude Code transcripts for the current directory plus git log, sorts the week into shipped, invisible, open, and abandoned, and prints it beside your own trailing four weeks, cut on the same weekday so the medians compare. Every number names the command and the date range that produced it, and derived numbers show their arithmetic. If you have not written a benchmark file with a source for your field, it says Unknown instead of quoting a figure from memory.

/standing

Why it helps specifically: the imagined peer cannot be argued with, because it does not exist. Your own trailing month can be. When the report shows the week beside the four before it, with the git command printed underneath, the comparison has a denominator, and a denominator is what the distortion was missing.

What Connects Them: The Codex

None of the three is a standalone trick. All of them read the same record underneath: a personal codex, a knowledge graph that grows with every session. Each node records one concept, its code references, and how it connects to other concepts.

A new project bootstraps with about 5 nodes. Mine has grown across a dozen repos because every session adds to it. librarian walks that graph so Claude does not start from scratch each time, and writes back whatever the walk surfaced. mirror uses the graph as the benchmark for what counts as progress on this project rather than a generic standard. standing reads git and the session transcripts, so the week’s invisible work counts too. The graph IS the memory. The skills are how you interact with it.

That is the part that compounds. You are not installing three standalone productivity tools. You are planting a seed. Every session makes the next session smarter, because the codex accumulates your decisions instead of forgetting them at the end of the conversation.

What This Looks Like in Practice

A real afternoon, lightly compressed, showing two of them working as a pair:

14:20 Need to change the auth schema but forget where it lives.
      /librarian  ->  "Hearing: change where sessions are stored.
                       Impacts: [auth-session, cookie-config].
                       Proposal: edit the schema in db/auth.ts:40-72  [Verified]"
      Navigation tax collapsed. No grep spiral.

17:30 Brain says "you got nothing done."
      /mirror  ->  "3 commits, schema migrated, cookie bug ruled out
                    as the cause. Here is the log."
      Distortion loses. The win counts.

None of them 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?

Before you write a skill, it helps to know which gap you are filling. The ADHD developer scorecard is a free two-minute read on where your executive function is leaking.

Do not build five skills today. Pick the one deficit that costs you the most and build or install 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 three 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.

If you know which gap is costing your team time but do not have the hours to build and test skills yourself, that is the engagement I run: custom Claude Code pipelines, $2,000 to $5,000, built around the specific workflow gap instead of a generic template. See how that engagement works.

The Three I Retired

The first version of this post listed five skills. Here is what happened to the other three, because a post about tools for a brain that cannot hold state should not itself hold stale state.

• adhd-task-triage (energy-based task initiation) was a skill on the claude.ai side, not a Claude Code skill, and its local directory was archived when I consolidated my setup. The idea, sorting by available energy instead of priority, still holds. It now lives in my task templates rather than a slash command.
• pickup (session resume) never got past its design document. Claude Code’s own session resume and my handoff notes covered enough of the gap that the skill was never worth building.
• schedule (time-blindness checkpoints) turned out to be a Claude Code built-in, not a skill of mine. The interval-checkpoint behaviour I described is the /loop command. Describing it as my skill was wrong, and I have corrected it.

The rule now: a skill appears in this post and in the repo only while it exists on my disk and I run it. standing joined the repo on 2026-09-04 under that rule.

ADHD Engineer’s Productivity System

The skills in this post work better when your task management matches how your brain prioritizes. I built Notion templates for exactly that: energy-based task management, two-axis filtering, and a brain dump capture system tuned for ADHD developers. $19.

Get the ADHD Engineer’s Productivity System ($19) →

Frequently Asked Questions

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

Are these built into Claude Code? No. Claude Code ships with a skill system and some bundled skills. mirror, librarian, and standing are custom skills I wrote for my own setup, published unedited in a public MIT repo. 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 undersells their progress, loses time rebuilding a mental map of a codebase, or measures a week against an imagined peer. ADHD just makes the gaps sharper, so the payoff comes faster.

How do I invoke a skill? Install per the install page, restart Claude Code, then type the slash command. 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. For what the research does and does not support about ADHD as a cognitive strength, see do people with ADHD have better pattern recognition.