Skip to content
BSWEN
Blog

Do AI Coding Assistants Help or Hurt Developers with ADHD?

Cowrie
Cowrie
Dev @ Bswen

The Problem

I looked at my clock. 2 PM. I looked again. 2 AM.

Twelve hours had vanished. I had built an entire feature with Claude, start to finish, without standing up once. My back ached, I was dehydrated, and I couldn’t remember if I’d eaten lunch.

Sound familiar? If you have ADHD and use AI coding assistants, you’ve probably experienced this.

A Reddit user put it perfectly:

“Vibe coding tools have created the perfect storm for my time blindness. There’s no separation between my normal life and my project life.”

Another reported:

“ADHD is now always-extreme-high. I went from having quarter-baked ideas to 200k line codebases.”

AI coding assistants like Claude, Cursor, and Copilot fundamentally change how ADHD brains interact with code. The question isn’t whether they help or hurt—it’s that they do both simultaneously, in ways that catch you off guard.

What’s Actually Happening

Let me break down the mechanism. ADHD affects developers in four key areas that AI coding assistants directly impact:

Traditional ADHD Challenges          AI Coding Assistant Effect
------------------------------      ---------------------------
Executive dysfunction               Bridges the gap (GOOD)
Focus dysregulation                 Amplifies hyperfocus (MIXED)
Dopamine seeking                    Creates supercharged loop (RISKY)
Working memory limits               Augments memory (GOOD)

The result? A productivity explosion that comes with hidden costs.

Executive Dysfunction: The Bridge

ADHD causes executive dysfunction—difficulty initiating tasks, organizing work, and following through. You know what you need to do, but you can’t make yourself start.

AI coding assistants bridge this gap perfectly.

Here’s how it works in practice. Before AI tools, starting a new feature meant:

Traditional workflow (ADHD nightmare):
1. Decide what to build
2. Plan the architecture
3. Set up the structure
4. Write boilerplate
5. Get distracted during step 4
6. Feel guilty
7. Abandon project

With an AI assistant, the friction points disappear:

feature_with_ai.py
# I just describe what I want:
# "Create a REST API endpoint that handles user authentication
#  with JWT tokens, rate limiting, and proper error handling"


# Claude generates the structure:
from fastapi import FastAPI, HTTPException, Depends
from fastapi.security import HTTPBearer
from datetime import datetime, timedelta
import jwt


app = FastAPI()
security = HTTPBearer()


# ... 150 lines of working code appear ...


# I'm immediately in "refine mode" instead of "blank page mode"

The blank page is gone. The initial friction is removed. Your ADHD brain doesn’t get stuck at the starting line.

This is why ADHD developers often report massive productivity gains. One user said they went from “quarter-baked ideas” to complete projects. The AI handles the executive function tasks—planning, organizing, structuring—that ADHD makes difficult.

Hyperfocus: The Amplifier

Here’s where it gets complicated.

ADHD brains experience hyperfocus—intense concentration on engaging tasks. It’s like a flow state, but harder to control. You can’t always choose what to hyperfocus on.

AI coding assistants make coding hyperfocus-friendly in three ways:

  1. Instant feedback loops: Every prompt gets an immediate response
  2. No tedious parts: The AI handles the boring work
  3. Continuous novelty: Each AI response is slightly different

This creates a hyperfocus trap:

hyperfocus_cycle.txt
Start coding
    ↓
AI responds quickly (dopamine hit)
    ↓
Brain says "more of this"
    ↓
Code more, AI responds more
    ↓
Hyperfocus deepens
    ↓
Time blindness kicks in
    ↓
Hours disappear
    ↓
Physical needs ignored
    ↓
Burnout approaches

A developer described this experience:

“My ADHD is now always-extreme-high. I used to have ups and downs in focus. Now it’s just constant hyperfocus until I physically can’t continue.”

Traditional coding had natural friction points—waiting for builds, debugging, looking up documentation—that gave your brain breaks. AI removes those friction points, and with them, the natural stopping points that help regulate ADHD work patterns.

The Dopamine Feedback Loop

ADHD brains are dopamine-seeking. We’re drawn to activities that provide immediate, rewarding feedback.

AI coding assistants create a dangerously effective dopamine loop:

dopamine_loop.py
class AICodingDopamineLoop:
    """
    The hidden mechanics of why AI coding feels addictive to ADHD brains.
    """


    def __init__(self):
        self.dopamine_triggers = {
            "instant_response": "AI responds in seconds",
            "working_code": "Code runs on first try",
            "progress_visibility": "See changes immediately",
            "novelty": "Each response is different",
            "accomplishment": "Complete tasks faster"
        }


    def trigger_rate(self):
        # Traditional coding: ~2-3 dopamine hits per hour
        # (solving a bug, feature working, passing tests)
        traditional = 2.5  # hits/hour


        # AI-assisted coding: ~20-30 dopamine hits per hour
        # (every AI response, every code block, every success)
        ai_assisted = 25  # hits/hour


        return ai_assisted / traditional  # 10x increase

The problem isn’t the dopamine itself—it’s that ADHD brains have poor impulse control around dopamine sources. We can’t easily stop doing things that feel good.

This explains why ADHD developers using AI tools report:

  • Difficulty stopping work sessions
  • Forgetting to eat, drink, or move
  • Working through exhaustion
  • Neglecting other responsibilities
  • Feeling “addicted” to coding

Memory Augmentation: The Hidden Benefit

Not everything is risky. AI coding assistants genuinely help ADHD developers in one critical area: working memory.

ADHD affects working memory—the ability to hold information in your mind while using it. Traditional coding requires juggling:

  • Function signatures you wrote hours ago
  • Variable names across files
  • API documentation
  • Bug context
  • Project structure

This is cognitively expensive for ADHD brains.

AI assistants act as external memory:

external_memory.ts
// Instead of remembering the exact API of my own code:
// "What parameters does processOrder accept?"


// I just ask the AI:
// AI: "processOrder(orderId: string, options?: ProcessOptions)"
//     "ProcessOptions includes: priority, skipValidation, callback"


// My brain is freed from memory juggling
// I can focus on the actual problem

One developer noted:

“I used to lose track of my own code structure. Now I just ask Claude what I wrote last week. It’s like having a perfect memory for code.”

This memory augmentation is why many ADHD developers feel AI tools are genuinely accessibility aids, not just productivity boosters.

Building a Healthy Workflow

The key is intentional friction. You need to design your AI-assisted workflow with ADHD-aware guardrails.

Here’s a pattern that works:

healthy_adhd_workflow.py
"""
ADHD-aware AI coding workflow with intentional friction points.
"""


import time
from datetime import datetime, timedelta
from dataclasses import dataclass
from typing import Optional


@dataclass
class WorkSession:
    start_time: datetime
    max_duration: timedelta
    break_interval: timedelta
    last_break: datetime


    def should_break(self) -> bool:
        """Check if it's time for a mandatory break."""
        return datetime.now() - self.last_break >= self.break_interval


    def should_stop(self) -> bool:
        """Check if session has exceeded max duration."""
        return datetime.now() - self.start_time >= self.max_duration


class ADHDAwareCodingSession:
    """
    A workflow that builds in friction points ADHD brains need.


    The goal: harness AI productivity while preventing hyperfocus traps.
    """


    def __init__(self, session_duration_minutes: int = 90):
        self.session = WorkSession(
            start_time=datetime.now(),
            max_duration=timedelta(minutes=session_duration_minutes),
            break_interval=timedelta(minutes=25),
            last_break=datetime.now()
        )
        self.pomodoro_count = 0


    def before_ai_prompt(self, prompt: str) -> Optional[str]:
        """
        Gate before sending prompts to AI.


        Returns None if session should pause, otherwise returns the prompt.
        """
        # Mandatory break check
        if self.session.should_break():
            self._enforce_break()
            return None


        # Hard stop check
        if self.session.should_stop():
            self._enforce_stop()
            return None


        # Log the interaction for self-awareness
        self._log_interaction(prompt)
        return prompt


    def _enforce_break(self) -> None:
        """Force a physical break."""
        print(">> MANDATORY BREAK")
        print(">> Stand up. Move. Drink water.")
        print(">> Wait 5 minutes before continuing.")


        # Simple blocking input
        input("Press Enter only after your break...")


        self.session.last_break = datetime.now()
        self.pomodoro_count += 1


    def _enforce_stop(self) -> None:
        """Force session end."""
        print(">> SESSION COMPLETE")
        print(f">> You completed {self.pomodoro_count} pomodoros")
        print(">> Save your work and close the editor.")
        print(">> Do NOT start another session for at least 2 hours.")


    def _log_interaction(self, prompt: str) -> None:
        """Track prompt frequency for self-awareness."""
        timestamp = datetime.now().strftime("%H:%M")
        print(f"[{timestamp}] Prompt #{self.pomodoro_count + 1}: {prompt[:50]}...")


# Usage:
# session = ADHDAwareCodingSession(session_duration_minutes=90)
#
# Before every AI prompt:
# prompt = session.before_ai_prompt("Help me implement authentication")
# if prompt:
#     # send to AI

The key principle: the AI shouldn’t remove all friction. Some friction serves a regulatory purpose.

Anti-Pattern: The “Slurm Session”

Here’s what happens without guardrails:

slurm_anti_pattern.py
"""
What NOT to do: The ADHD hyperfocus trap.


This pattern leads to burnout, health issues, and unsustainable work habits.
"""


# Bad: Unlimited AI-assisted coding
while True:
    prompt = get_next_feature()
    code = ai.generate(prompt)
    integrate(code)
    test()
    # No breaks, no limits, no awareness
    # This can continue for 12+ hours


# ADHD brain loses track of:
# - Time (hours pass like minutes)
# - Body (hunger, thirst, movement ignored)
# - Context (other responsibilities forgotten)
# - Limits (when to stop, when good enough)


# Result pattern reported by users:
# Day 1-3: Incredible productivity (200k line codebase!)
# Day 4-7: Exhaustion, inability to focus on anything
# Day 8+: Need to take days off to recover
# Repeat cycle

The “slurm” reference comes from a Reddit user who compared AI coding sessions to Futurama’s Slurm: incredibly addictive, consumed in massive quantities, and not sustainable.

Building ADHD-Aware AI Tools

If you’re building AI coding tools, consider ADHD users in your design:

adhd_aware_features.ts
/**
 * Features that help ADHD developers use AI tools sustainably.
 */


interface ADHDUserFeatures {
  // 1. Session awareness
  sessionTimer: {
    showDuration: boolean;        // "You've been coding for 2 hours"
    suggestBreak: boolean;        // "Consider a 5-minute break"
    hardLimit: number | null;     // Optional enforced maximum
  };


  // 2. Progress anchoring
  taskTracking: {
    showCompletedCount: boolean;  // "3/5 tasks done"
    preventScopeCreep: boolean;   // Warn when adding new tasks mid-session
    celebrateCompletion: boolean; // Dopamine from finishing, not just coding
  };


  // 3. Friction restoration
  intentionalPauses: {
    betweenPrompts: boolean;      // Brief pause before showing response
    confirmLargeChanges: boolean; // "This will modify 20 files. Continue?"
    summarizeBeforeContinue: boolean; // "Here's what we've done. Ready for more?"
  };


  // 4. Self-awareness prompts
  wellbeingChecks: {
    intervalMinutes: number;      // Every 30 minutes
    prompts: string[];            // "Have you drunk water?"
  };
}


// Example implementation
const defaultADHDConfig: ADHDUserFeatures = {
  sessionTimer: {
    showDuration: true,
    suggestBreak: true,
    hardLimit: 180  // 3 hours max
  },
  taskTracking: {
    showCompletedCount: true,
    preventScopeCreep: true,
    celebrateCompletion: true
  },
  intentionalPauses: {
    betweenPrompts: true,
    confirmLargeChanges: true,
    summarizeBeforeContinue: true
  },
  wellbeingChecks: {
    intervalMinutes: 30,
    prompts: [
      "Quick check: Have you moved in the last hour?",
      "Self-assessment: Are you still making progress or spinning wheels?",
      "Hydration reminder: Drink some water"
    ]
  }
};

These features wouldn’t slow down neurotypical users, but they would significantly help ADHD developers maintain sustainable work patterns.

The Two Sides of the Same Coin

I’ve experienced both sides of this coin. My AI-assisted coding sessions have produced some of my best work—and some of my worst burnout.

The same mechanisms that help me bridge executive dysfunction also trap me in hyperfocus. The same dopamine loop that makes coding feel effortless also makes it hard to stop.

Here’s what I’ve learned works for me:

  1. External timers: Not willpower. A physical timer that makes noise.
  2. Session boundaries: Defined start and end times before I begin
  3. Accountability: Another human who checks if I’m still coding
  4. Physical environment: Work somewhere you can’t stay indefinitely
  5. Post-session rituals: Something that signals “coding time is over”

The Reddit user who said “I just call this ADHD” was right. These tools don’t create new problems—they amplify existing ADHD traits, both good and bad.

Summary

In this post, I explored how AI coding assistants affect ADHD developers. The key insight is that these tools are a double-edged sword: they bridge executive dysfunction gaps and augment working memory, but they also amplify time blindness and risk of burnout by removing friction points that help regulate ADHD work patterns.

The solution isn’t to avoid AI tools—it’s to build intentional friction back into your workflow. Set session limits, take mandatory breaks, and create external accountability. The productivity gains are real, but they require sustainable practices to maintain.

If you’re an ADHD developer using AI tools, pay attention to your patterns. Notice when you’re in a healthy flow versus a hyperfocus trap. Your future self will thank you for building guardrails now.

Final Words + More Resources

My intention with this article was to help others share my knowledge and experience. If you want to contact me, you can contact by email: Email me

Here are also the most important links from this article along with some further resources that will help you in this scope:

Oh, and if you found these resources useful, don’t forget to support me by starring the repo on GitHub!

Comments

Tags: