I have AuDHD — the combination of autism and ADHD. Specifically ADHD-PI: the inattentive variant, without the hyperactivity most people associate with ADHD.

This isn’t an excuse. It’s context.

Because the way I work — the obsession with automation, the preference for async communication, the hours I invest in tooling — doesn’t come out of nowhere. It’s the result of years of experimenting with what works for a brain that isn’t built for the standard office world.

And here’s the interesting thing: the strategies I use out of necessity work for everyone. The difference is that I don’t have a choice. For me, it’s survival. For you, it’s optimization.

What AuDHD looks like (for me)

Let me be specific, because “neurodivergent” is a broad term.

The ADHD side:

  • Regulating attention is inconsistent. Sometimes I can’t focus, sometimes I can’t stop focusing (hyperfocus)
  • Starting tasks is often harder than doing tasks. The threshold to begin can feel insurmountable
  • My working memory is limited. If it’s not written down or automated, it doesn’t exist
  • Urgency drives action. Without a deadline, a task barely exists in my brain

The autism side:

  • Predictability is calm. Unexpected changes cost energy
  • Patterns and systems are how I understand the world
  • Context switching is expensive. Every interruption takes time to recover from
  • Sensory input can be overwhelming. Open offices are exhausting

The combination:

  • I want structure (autism) but struggle to create it myself (ADHD)
  • I need routines but my brain gets bored quickly with repetition
  • I can focus deeply but can’t choose on what

This might sound like a recipe for failure. And yes, for years it was. Until I stopped fighting against my brain and started working with it.

The three principles

Everything I do — from my tech stack choices to how I structure my day — comes down to three principles:

1. Minimize cognitive friction

Every extra step between me and a task is a point where my brain can check out. Every decision I have to make depletes a limited supply.

Therefore:

  • Automation over manual steps. A script doesn’t forget steps. My brain does.
  • GitOps over ad-hoc changes. The desired state is in Git. I don’t have to remember what I changed where.
  • CLI over GUI. Less visual distraction. One command, one action.
  • Infrastructure as Code. The infrastructure is documented by the fact that it exists. No separate documentation to maintain.

The less my brain has to work to get something done, the greater the chance it actually happens.

2. Facilitate flow state

My brain has two modes: unable to focus, or hyperfocus. The latter is gold — but fragile. One interruption and I lose it.

Therefore:

  • Async communication as default. I decide when I read messages, not my inbox.
  • Deep work blocks. Mornings are for focus. Meetings in the afternoon.
  • Notifications off. All of them. Always. I check things when I’m ready for them.
  • Tooling that supports my flow. Keyboard shortcuts, terminal workflows, everything to stay in the same context.

Once I’m in flow, I can move mountains. The art is reaching that state and protecting it.

3. Build external structure

My brain struggles to create and maintain structure itself. The solution: build the structure into the environment instead of in my head.

Therefore:

  • Declarative configuration. The desired state is explicit. Not “I configured this somewhere once” but “this is what it should be.”
  • Self-healing systems. When something fails, it fixes itself. I don’t have to remember to fix it.
  • GitOps. The git repository is the source of truth. Not my memory.
  • Pipelines that enforce. Tests, linting, security scans — if it’s not in the pipeline, I’m going to forget it.

The system remembers. The system enforces. I only have to build.

Why this works for you too

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

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

Cognitive load is finite for everyone. Decision fatigue is universal. The dopamine hit of new things versus the boredom of maintenance — everyone recognizes that.

The difference is that my tolerance for friction is lower. Where you might be able to remember three manual steps, I check out at the first one. Where you can choose to leave notifications on, I can’t.

But the solutions I have to use are the same ones that make your work better too:

  • Automation reduces errors and saves time — for everyone
  • Async communication increases deep work — for everyone
  • Declarative configuration makes systems more understandable — for everyone
  • Self-healing infrastructure reduces operational load — for everyone

I’m just the canary in the coal mine. If it works for me, it probably works for you too.

What this looks like in practice

This blog explores concrete implementations of these principles. For example:

The core

For a long time I thought I had to change. That I had to try harder. That discipline was the solution.

That doesn’t work.

What does work: accepting how my brain functions and building around it. Creating systems that work with me instead of against me.

And the funny thing is that those systems — automation, async, declarative configuration, self-healing infrastructure — are just good engineering. They’re not “for people with ADHD.” They’re for everyone who wants reliable, maintainable systems.

I just don’t have a choice to do it differently.

This is the context for much of what I write. If you’re wondering why I’m so focused on automation, why I preach GitOps, or why I recommend async communication — this is why. Not because it’s trendy. Because my brain can’t do it any other way.