I have a problem. Not a dramatic problem, not a “my life is falling apart” problem. A compulsive problem. I see a repetitive process and my brain immediately starts decomposing it into automatable steps. I can’t turn it off. I’ve been like this since I was ten years old, and at this point I’m pretty sure it’s just how I’m wired.

The first thing I ever automated was a MUD. I was a kid with a 2400 baud modem, logged into a text game, and I noticed that leveling up meant typing the same combat commands over and over. attack goblin. Wait. attack goblin. Wait. Loot. Heal. Repeat. So I wrote a script. A terrible, brittle little thing in a MUD client’s macro language that watched for specific text patterns and fired commands in response. It played the game for me while I slept.**

I didn’t think of it as “automation” at the time. I thought of it as winning. But looking back, that was the moment the pattern locked in: see a system, understand its protocol, write something that talks to it for you. I’ve been doing the same thing for twenty years. The systems got bigger. The scripts got better. The compulsion never changed.

The Networking Years

I spent years working in network operations. BGP, OSPF, MPLS, all the acronym soup that keeps the internet stitched together. And if you’ve ever worked in networking, you know the dirty secret: half the job is repetitive configuration changes across dozens of devices.

Need to add a new VLAN across thirty switches? That’s a script. Need to update BGP communities on every edge router in a region? Script. Need to audit ACLs for compliance? Script. Need to generate a topology diagram from LLDP neighbor tables? Believe it or not, also a script.

I wrote tools that SSH’d into routers, parsed their output (which, fun fact, is never consistent between firmware versions; ask me how I know), made decisions based on the current state, and applied changes. I wrote tools that monitored BGP sessions and paged me only when the flapping exceeded a threshold I’d tuned through painful experience. I wrote tools that generated change request documentation automatically because filling out the same form template by hand was making me lose my mind.

Some of my coworkers thought I was being clever. A few thought I was being lazy. The ones who’d been doing the same job for ten years and still copy-pasted configs from Notepad thought I was showing off. I wasn’t. I was just physically incapable of doing the same thing twice when a script could do it forever.

The throughline of my entire networking career wasn’t routing or switching or security. It was making the computer do the boring parts so I could focus on the interesting parts. Every protocol I learned, I learned just well enough to automate it. That’s not a flex; it’s a confession. I never became a deep BGP expert. I became an expert at making scripts that talked BGP for me. 😅

The Build Pipeline Disease

Fast forward to now. I build websites. I write shaders. I run a blog. And the automation disease has, if anything, gotten worse.

Let me tell you about my blog’s build pipeline, because it’s a perfect case study in “this started as one script and now it’s an ecosystem.”

When I write a blog post, here’s what happens when I run make prod:

  1. A Python script crawls my content directory, chunks every blog post into semantic segments, and generates vector embeddings using a local HuggingFace model
  2. Those embeddings get written to a JSON file that ships as a static asset
  3. Vite builds all my TypeScript, GLSL shaders, and assets with content hashing
  4. Jekyll processes the Markdown into HTML with Liquid templates
  5. Everything gets composited into a final build directory
  6. A local HTTPS server spins up with my wildcard SSL cert so I can preview on real devices across my Tailnet

One command. I type make prod and go get coffee. When I come back, the site is built, embeddings are fresh, and it’s serving over HTTPS on horus.ellyseum.dev. If something breaks, Make tells me which step failed. If nothing breaks, I push to main and GitHub Pages deploys it.

I could do these steps manually. I did, once. It took twelve minutes and I had to remember the right flags for four different tools. Now it takes one command and about ninety seconds, and more importantly: I can’t get it wrong. The Makefile doesn’t forget flags. The Makefile doesn’t accidentally skip the embedding step. The Makefile doesn’t typo a path. I do all of those things constantly, but the Makefile doesn’t.

Claude Code and the “Just Do It” Workflow

Here’s where it gets meta. My most recent automation isn’t a shell script or a Makefile. It’s an AI.

I use Claude Code as a development collaborator, and I’ve set it up with a bunch of context files and custom skills that encode my preferences, my voice, my project structure. When I want to write a blog post, I don’t open a blank file and stare at it. I invoke a skill that pulls my voice guide, my recent writing samples, my topic notes, and drops all of it into context. Then I talk through what I want, and we write it together.

When I want to edit code, I don’t open a file and scroll to line 247. I describe what I want changed, and it changes it. My global instructions literally include the phrase: “When told to do something, do it. Don’t ask me to copy-paste commands or do steps manually.” I automated away the question “are you sure?” because yes, I’m sure, I wouldn’t have asked if I wasn’t sure.

Is this still scripting? I think it is. The “script” is a set of instructions that encode my intent and preferences so that a system can execute on my behalf without me micromanaging every step. That’s what a shell script does. That’s what a Makefile does. That’s what a BGP automation tool does. The execution engine changed from Bash to an LLM, but the pattern is identical: define the protocol, encode the intent, let the machine handle the execution.

I’ve been doing this same thing my whole life. The machine just got better at understanding what I mean.

Testing While I Sleep

And then there’s EllyMUD. I built a MUD (a text-based multiplayer game, for the uninitiated) and I automated the testing with AI agents that play the game overnight.

The TesterAgent connects to the game server, logs in, wanders around, tries commands, fights monsters, buys things from merchants, and reports what broke. It does this at 3 AM while I’m unconscious. I wake up, check the logs, and find out that the “drop” command crashes if you try to drop an item you’ve already equipped, or that a goblin in the caves has somehow accumulated forty-seven swords because the loot despawn timer has an off-by-one error.

I did not set out to build a QA department staffed by AI agents. I set out to write a test, and then I thought “what if the test played the game instead of just checking assertions,” and then I thought “what if it played the game all night,” and then suddenly I had a QA department staffed by AI agents. This is how the disease works. You automate one thing and it suggests the next thing and the next thing and you look up three weeks later and you’ve built infrastructure. 🏗️

The Compulsion

I’ve been thinking about why I’m like this, and I think it comes down to something simple: I hate doing things twice.

Not in a lazy way. In an offended way. If I’ve solved a problem once, solving it again manually feels like a waste of the first solution. The knowledge should be encoded somewhere. In a script, a config file, a Makefile target, a set of AI instructions. Somewhere that isn’t my unreliable meat brain, which will absolutely forget the correct flag order by next Tuesday.

Every automation I’ve ever built started the same way. I did something manually. I did it again. On the third time, something in my brain snapped and I thought: no. We’re not doing this again. We’re writing something that does this forever.

The MUD scripts. The BGP tools. The build pipeline. The Claude Code skills. The AI test agents. They’re all the same impulse wearing different costumes. See a system, understand the protocol, make a machine do it.

The Part Where I Acknowledge This Is Slightly Unhinged

Look. I know that writing a custom embedding pipeline for a blog that gets maybe a hundred visitors is overkill. I know that building AI test agents for a hobby MUD is, charitably, “over-engineered.” I know that my Makefile has more targets than my site has pages.

I don’t care! 🎉

The automation isn’t really about saving time. Some of it saves time, sure. The build pipeline saves me twelve minutes per deploy. The BGP tools saved me hours per change window. But the blog embedding pipeline? That saves me maybe thirty seconds of running a script manually. The AI test agents? I could just play the game myself and find the bugs.

The automation is about encoding understanding. When I automate something, I have to understand it deeply enough to describe it precisely to a machine. The script is the documentation. The Makefile is the architecture diagram. The automation isn’t a shortcut around understanding; it’s proof that understanding happened.

And honestly? It’s just fun. It’s the same fun I had at ten years old, watching my MUD character fight goblins while I slept. The thrill of making a machine do something on your behalf. Of writing instructions so precise that a computer, which understands nothing, does exactly the right thing.

I’ve been chasing that feeling for twenty years. The systems got bigger, the scripts got smarter, and the machines started understanding natural language instead of just regex patterns. But the core loop hasn’t changed: see a system, learn its protocol, make it dance.

I don’t think I’ll ever stop. 🚀