For a long time I thought the problem was me.

I have AuDHD: the combination of autism and ADHD. Specifically ADHD-PI, the inattentive variant, without the hyperactivity most people picture when they hear ADHD. For years I treated that as a defect to overcome. I bought the planners. I read the productivity books. I told myself that next Monday I’d finally be disciplined.

This post is the story of how that approach failed, what I built instead, and why the systems I ended up depending on turn out to be good engineering for anyone.

It’s context, not an excuse. The obsession with automation, the preference for async communication, the hours I sink into tooling: none of it comes out of nowhere. It’s the residue of a long argument I had with my own brain, and lost.

The years I tried to fix myself

Here’s what a default office world asks of you. Hold a dozen things in your head at once. Switch contexts on demand when someone taps you on the shoulder. Sit in an open-plan room with the sensory volume cranked to eleven. Start the boring task because it’s on the list, not because anything makes it urgent. Stay focused for eight hours, evenly, like a machine that doesn’t get bored.

My brain can’t do that, and pretending it could was exhausting.

Let me be specific, because “neurodivergent” covers a lot of ground.

The ADHD side:

  • Regulating attention is inconsistent. Some days I can’t focus, other days I can’t stop (hyperfocus)
  • Starting a task is harder than doing it. The threshold to begin can feel like a wall
  • My working memory is small. If it’s not written down or automated, it doesn’t exist
  • Urgency drives action. Without a deadline, a task barely registers

The autism side:

  • Predictability feels calm. Unexpected changes drain energy
  • Patterns and systems are how I make sense of the world
  • Context switching is expensive. Every interruption has a recovery cost
  • Sensory input piles up. Open offices wear me down

The combination:

  • I crave structure (autism) but struggle to generate it myself (ADHD)
  • I need routines, yet repetition bores me fast
  • I can focus deeply but rarely get to choose on what

For years I read that list as a diagnosis of failure. The fix was always the same advice: try harder, be more disciplined, want it more. So I tried harder. I wanted it more. And I kept ending the week with the important task still untouched and a vague sense that everyone else had been issued an operating manual I never received.

The afternoon I gave up

The shift didn’t arrive as a breakthrough. It arrived as exhaustion.

I’d set up yet another manual routine to keep myself on track, and I’d let it rot within a week, the way I always did. Instead of the usual guilt spiral, I asked a different question. Not “why can’t I stick to this?” but “why am I the one expected to remember?”

That question changed the target. The problem wasn’t my discipline. The problem was that I’d built everything to run on willpower, and willpower is the one resource my brain refuses to supply on demand. So I stopped trying to become a person who remembers, and started building an environment that remembers for me.

That’s a small reframe on paper. In practice it rewired how I work.

What I built instead

Once I stopped fighting my brain, the choices fell out of three principles. They’re not productivity hacks I collected. They’re load-bearing walls.

1. Minimize cognitive friction

Every extra step between me and a task is a place where my brain can quietly check out. Every decision I have to make spends from a budget that’s smaller than most people’s.

So:

  • Automation over manual steps. A script doesn’t forget step four. I do.
  • GitOps over ad-hoc changes. The desired state lives in Git. I don’t have to recall what I changed where.
  • CLI over GUI. Less on screen to pull my attention. One command, one action.
  • Infrastructure as Code. The infrastructure documents itself by existing. No separate docs to let go stale.

The less work it takes my brain to get something done, the higher the odds it actually happens. That’s the whole calculation.

2. Facilitate flow state

My brain runs in two modes: can’t focus, or hyperfocus. The second one is where I do my best work, and it’s fragile. One interruption and it’s gone, and I can’t summon it back on command.

So:

  • Async communication as the default. I decide when I read messages. My inbox doesn’t decide for me.
  • Deep work blocks. Mornings are for focus. Meetings get herded into the afternoon.
  • Notifications off. All of them. I check things when I’m ready, not when something pings.
  • Tooling that holds the flow. Keyboard shortcuts, terminal workflows, anything that keeps me in one context.

When I reach flow I can move mountains. The hard part is getting there and then guarding it from interruption.

3. Build external structure (systems over willpower)

This is the one that took the longest to accept. My brain can’t reliably build and hold structure on its own, so I put the structure in the environment instead of in my head.

So:

  • Declarative configuration. The desired state is written down and explicit. Not “I configured this somewhere once,” but “this is what it should be.”
  • Self-healing systems. When something fails, it recovers on its own. I don’t have to remember to fix it.
  • GitOps. The git repository is the source of truth. My memory isn’t.
  • Pipelines that enforce. Tests, linting, security scans. If it’s not in the pipeline, I will forget it.

The system remembers. The system enforces. I just have to build it once.

What it cost me

I want to be honest, because this isn’t free.

Building external structure is real work up front. Writing the automation, wiring the pipeline, making the config declarative: all of that is slower than just doing the thing by hand once. There were stretches where I was clearly over-engineering a problem to avoid having to remember it, and I had to learn where that line was.

And accepting how my brain works meant giving up a story I’d told myself for years, that one more push of discipline would finally make me normal. Letting go of that felt like loss before it felt like relief.

The trade I made: pay the cost once, in building the system, instead of paying it every single day in willpower I don’t have.

Why this works for you too

“But Tom, I don’t have ADHD. Why should I care?”

Because your brain also prefers to do as little work as possible.

Cognitive load is finite for everyone. Decision fatigue is universal. The pull of a shiny new thing against the dull weight of maintenance is something we all feel. The difference is my tolerance for friction is lower. Where you might hold three manual steps in your head, I lose the thread at the first one. Where you can choose to leave notifications on, I can’t.

The solutions I’m forced into are the same ones that quietly improve everyone’s work:

  • Automation cuts errors and saves time, for everyone
  • Async communication protects deep work, for everyone
  • Declarative configuration makes systems understandable, for everyone
  • Self-healing infrastructure lowers operational load, for everyone

I’m the canary in the coal mine. If a workflow survives my brain, it’ll probably survive yours.

What this looks like in practice

This blog works through concrete versions of these principles. For example:

Where I landed

I used to think discipline was the answer, and that I just needed more of it. I was aiming at the wrong target.

What actually works is accepting how my brain functions and building around it. Systems that work with me instead of against me. The funny part is that those systems, automation, async, declarative config, self-healing infrastructure, are simply good engineering. They were never “ADHD tips.” They’re for anyone who wants reliable, maintainable systems. I’m just the person who couldn’t get by without them.

So when you read me arguing for automation, preaching GitOps, or pushing async communication, this is the reason underneath it. Not because it’s trendy. Because my brain genuinely can’t work the other way, and once I stopped pretending otherwise, the work got better.