How I Use Claude Code to Compensate for ADHD Executive Function

Executive Function: The ADHD Tax on Professional Work

Every task you do carries a tax you can't see on your calendar.

Before you write the email, you have to decide to write the email. Before you decide, you have to remember the email exists. Before you remember, you have to pull yourself out of whatever your brain wandered into since the last time you thought about it.

That's executive function. And if you have ADHD, you pay that tax at a higher rate than everyone around you.

Executive function is a collection of cognitive processes that neurotypical professionals take for granted:

• Working memory holds information in your head while you use it. "I'm writing this proposal. The client wants three options. Budget is $50K. They need it by Thursday." For ADHD brains, that mental sticky note falls off the wall every time someone pings you on Slack.
• Task initiation is the ability to start things. Not motivation. Not desire. The literal neurological bridge between "I know I should do this" and doing it. When that bridge has a gap, you spend two hours reorganizing your task list instead of working.
• Self-monitoring is checking your own work for quality, catching errors, knowing when you're done. Your brain wants to move on to the next interesting problem while the current one still has typos in it.
• Time management and emotional regulation round out the list, but you already know about those. You've lived them.

For most ADHD professionals, the overhead around the work is the real problem. The loading, the switching, the checking, the starting. The work itself? That part is usually fine.

I've spent the last year building a system that compensates for these specific deficits using Claude Code. Not a productivity app. Not another thing to manage. A set of files, commands, and validation layers that function as external executive function.

If you've read why ChatGPT makes ADHD worse, you know the failure mode: chatbot interfaces create more decisions, more open loops, more scattered context. What I'm describing here is the opposite approach. Structured. Persistent. File-based. And it works with ADHD instead of against it.

Working Memory Compensation

The biggest cost of ADHD in professional work is context loss. You were deep in a project. You got interrupted. Now you need 30 minutes to reconstruct where you were, what you'd decided, and what was next.

Claude Code solves this because it reads files, not chat history.

The foundation is a file called CLAUDE.md that sits in the root of your project. Claude Code reads it automatically at the start of every session. It contains your project context, your conventions, your workflows, your architectural decisions.

CLAUDE.md contains:
- What this project is and who it's for
- Active systems and their current status
- Database schemas and API patterns
- Common workflows (/morning-kickoff, /begin, /end)
- Known gotchas that would otherwise bite you every time

When you open Claude Code on Monday morning and can't remember what you were doing Friday, you don't have to. The AI already knows. Your project context is right there in the file system.

But CLAUDE.md is just the start. I use a memory/ directory that works as long-term storage across sessions:

memory/
  semantic/patterns/    - Learned patterns and reusable knowledge
  episodic/sessions/    - What happened in each work session

Episodic memory files capture what I did, what decisions I made, and where I left off. When I come back after a weekend (or after an afternoon of completely forgetting this project existed), I can ask "What was I working on?" and get an answer grounded in actual files, not vague recollection.

This is external RAM for your brain. The file system holds context that your working memory can't. And because it's files, not chat history, it doesn't degrade. It doesn't scroll away. It doesn't vanish when you close a tab.

For the ADHD professional, "where was I?" becomes a 10-second answer instead of a 30-minute archaeological dig.

Task Initiation Compensation

If you have ADHD, you know the feeling. You sit down to work. You have 15 things to do. You know exactly what they are. And your brain refuses to pick one.

This isn't laziness and it isn't procrastination. Task initiation is a distinct executive function, and ADHD impairs it directly. The gap between "knowing what to do" and "doing it" can feel like trying to push a car that's in neutral.

My solution: reduce the decision to zero.

I built a /morning-kickoff command that works like this:

You type: /morning-kickoff

Claude Code then:
1. Checks your calendar for today's meetings and deadlines
2. Reads your task list and open issues
3. Looks at what you were working on yesterday (from session memory)
4. Considers energy patterns (morning = deep work, afternoon = admin)
5. Picks your first task
6. Loads the relevant context
7. Starts working

You went from "stare at screen for 45 minutes" to "working within 2 minutes." The decision about what to do was made by the system, not by your executive function.

The same principle applies to /begin. When I start a work session, I type:

/begin fix the email automation bug

This single command creates a task in my project management system, creates a Git branch, creates a GitHub issue, and loads all the relevant context for that piece of work. I don't have to decide how to organize the work. I don't have to set up the environment. I don't have to find the right files. One command, and I'm already inside the task.

The key insight: every decision you eliminate is one less opportunity for paralysis. ADHD task initiation breaks down at the decision layer, not the execution layer. Once you're moving, you're often fine. The problem is getting the car out of neutral.

So I built a system where the car is already in drive.

Self-Monitoring Compensation

I can write a 2,000-word blog post in an hour. Checking it for errors? My brain would rather do anything else on earth.

Self-monitoring, the ability to evaluate your own output, is another executive function that ADHD disrupts. Your brain is wired to chase the next interesting problem, not to review the last one. So you ship work with typos. You send proposals with inconsistent formatting. You publish posts where the second half doesn't match the tone of the first half.

The solution: automated validation that catches what my brain skips.

In my Second Brain setup, I have validation skills that run as quality gates before anything ships:

npm run validate-writing growth/blog/my-post.md

Checks:
- AI pattern detection (no robotic-sounding phrases)
- Forbidden buzzword scan
- Formatting consistency
- Structural completeness

For code, the pattern is similar:

npm run build    # Does the code actually compile?
npm run lint     # Are there obvious errors?
/validate-build  # Full production readiness check

For newsletters and LinkedIn posts, I have evaluation skills that score content on multiple dimensions before I publish. The scoring catches problems I would otherwise miss: weak hooks, structural gaps, voice inconsistency.

This changes the emotional relationship with shipping work. Instead of anxiety about what I might have missed, I have a system that checks for me. My brain can move on to the next thing because I trust the validation layer.

The relief is hard to overstate. If you've ever hit send on a client email and immediately wondered "did I proofread that?" you know the feeling. Now imagine never having that feeling because an automated check already confirmed the email was clean.

For an ADHD brain, this is the difference between shipping confidently and shipping with dread.

Context Switching: The Compound Problem

I want to address one more pattern because it compounds all the others.

Research from the University of California Irvine suggests it takes about 23 minutes to regain focus after an interruption. For ADHD brains, the cost is worse because you don't just lose focus. You lose the entire mental model. The meeting, the Slack message, the random thought about what to have for dinner: each one wipes your working memory clean.

This is where the file-based system creates compound value.

Every interruption that used to cost 30 minutes of reconstruction now costs about 60 seconds. You come back, Claude Code reads the CLAUDE.md and session memory, and you're back in context.

Over an 8-hour workday with, say, 6 interruptions (conservative for most ADHD professionals), that's the difference between losing 3 hours to context reconstruction and losing 6 minutes.

The math is simple. The impact on your ability to actually ship work is massive.

MCP integrations make this even more powerful. Claude Code connects directly to my Gmail, Calendar, CRM, and GitHub through MCP servers. When I get interrupted by a client email and need to switch contexts, I don't have to manually pull up the client's history. The AI can read the email thread, check the CRM for deal status, review the project repo, and give me a full brief in seconds. Then when I switch back to what I was doing before, the session context is still there.

Your brain doesn't have to hold any of it. The system holds it all.

Accessibility, Not Optimization

I want to be direct about what this is.

The productivity community loves to frame everything as optimization. 10x your output. Ship faster. Do more with less. And sure, this system does make me faster.

But for ADHD professionals, that framing misses the point.

When a person with poor vision gets glasses, we don't call it "vision optimization." We call it corrective. It brings them to baseline. It removes a barrier that made normal tasks harder than they should be.

That's what external executive function does for ADHD. It brings you to baseline.

Working memory compensation means remembering as much as your colleagues do without thinking about it. Task initiation compensation means starting tasks at all, without the 45-minute paralysis tax. And self-monitoring compensation means catching the errors your brain would catch if it weren't already three problems ahead.

I built this system because I needed it, and I now run my whole business through it, which is the day-in-the-life ADHD case study I wrote up in full. I sell it through Second Brain for ADHD because I know other professionals need it too. Not as a "productivity hack." As infrastructure that makes professional work accessible for brains that work differently.

The hyperproductivity narrative around ADHD is real, by the way. ADHD brains can produce extraordinary work, especially in novel, creative, high-stakes contexts. But that capacity gets buried under the executive function tax. Reduce the tax, and the brilliance comes through.

Claude Code isn't the only way to build this kind of system. But its file-based architecture, persistent context model, and extensibility through skills and MCP integrations make it the best foundation I've found. Every piece of your external executive function lives as a file you can read, edit, and version control. Nothing is locked in a chat thread. Nothing disappears when you close the window.

Your context persists. Your workflows reduce decisions. Your validation catches mistakes.

And your brain gets to do what it's actually good at.