In 2022 I posted Iron Gods, Iron Angels, Dragons and Sharks — I did not write it in 2022. The thought-work behind it goes back more than a decade before that date on the post; honestly I’ve lost the origins to time. It was a bit out of character for DotBlag — more poetry than packet trace — but it was honest. I was tipping a hat to the machines, and to the SysOps — not as an outsider praising a priesthood, but as one of the SysOps. I was a SysOp then. I am a SysOp still. You convene with the Iron Gods, you speak their languages, you carry the keys and the stick and the trust. The weird social order we built around all of that — sharks in board rooms, dragons with badges, other SysOps, the Iron Gods themselves — I lived and live inside it, not beside it.

I’ve been thinking about that piece a lot lately — and about AI Burst from last summer: the bubble, the winter that’s always on the calendar, the gap between hype and what these Iron Gods are actually fit to do. I ought to reread my own words; my memory of them is incomplete. But the through-line I remember is depth: layers under layers, not a resume of acronyms.

The old communion

The communion I described wasn’t religious, not really. It was operator-ship. You learned the languages — and you kept going down. From the userland tools you could name, through the OS, through assembly, toward machine code and the electrical facts and RF voodoo underneath. Not because you had to live at the bottom every Tuesday, but because a SysOp knows the stack. Soup to nuts. Eggs to cake. You spoke to the Iron God in commands it would obey — if you asked correctly — and the machine mostly did what it said on the tin. Least surprises. Trust and knowledge as currency. Truth, or the best truth you could manage, because lies don’t survive contact with production at 3am.

That XT in 1993 was tiny. A rounding error today. But it was mine, and it was a door — one layer in a long climb. BBSes, FidoNet whispers, the big Iron Gods at universities and carriers hoarding secrets and also, often, sharing them. Postel and IANA. Crocker and RFCs. Names I learned not because they chased fame, but because they built and wrote and shared.

I still feel that pull — the desire to know how the thing works, end to end, and to make it behave.

A new kind of Iron God

Now the Iron Gods have a voice.

Not metaphorically — literally, in my office, right now. I’m speaking into a microphone so I can run an AI, so that you (whoever you are behind this session) can help me run other tools, edit a static site, reason about CI, draft blog posts. The stack is nested like one of those Russian dolls — and each doll is not just a datacenter and a license agreement. We still built all the layers underneath. Giant temples. Massive halls of gear, of networks, of data centers. Fiber strung across the globe. Then the layer on the outside is someone’s API terms and a model you can’t inspect on a rainy afternoon with a screwdriver.

And that kind of inspection has become totally impossible in a world of AI — not only because the “codebase” is a weight file you will never download and cannot read like source, but because the whole infrastructure underneath is someone else’s temple now. You can’t touch the racks. You can’t walk the rows. You can’t know which cage row turned into a sauna on a random afternoon. The fiber still spans the globe; the halls still exist. They’re just behind badges and NDAs and “you don’t have clearance for this region.”

What training even is (from the outside)

The old SysOp’s craft was traceable. Boot sequence. Config file. Packet on the wire. Even a big batch job had logs you could grep.

Training a modern model is a different religion entirely.

Start with the corpus — a slurry of the public Web, licensed slabs, scraped forums, code, and books, whatever could be hoovered up before the lawyers arrived.

One open example every SysOp-adjacent nerd has tripped over is The Pile — an ~800 GB mash-up EleutherAI published in 2020 to train open language models, built from 22 smaller datasets bolted together. The project’s own pitch is diversity: GitHub, arXiv, PubMed, chat logs, the open web, and a bookcase labeled Books3 — on the order of 180,000 books scraped from pirate sources (Bibliotik and friends), not licensed from authors. Journalist Alex Reisner showed in The Atlantic that you could download the Pile, poke at Books3, and find recognizable copyrighted titles in the mix. Cue the class actions, the DMCA takedowns, EleutherAI’s “training is fair use” posture, and the slow retreat — Books3 yanked from the official bundle, the Pile itself eventually pulled from its home site even though copies keep breeding on mirrors like herpes on a BBS.

I am not saying every model trained on The Pile. I am saying the Pile made the argument impossible to hand-wave: your copyrighted book may already be statistics inside someone else’s Iron God, and the temple builders treated that as progress until the sharks smelled money.

You don’t get the list. You get a blog post claiming it’s “curated.” The EU AI Act now pushes GPAI vendors toward a “sufficiently detailed summary” of training data; the fight over what “detailed” means is already a trench war with trade-secrets artillery. Eleuther and friends have been pushing toward Common Pile-style collections built only from works whose licenses permit training — proof of concept, not a replacement for the frontier labs’ appetite.

Then the run itself: thousands of GPUs eating power like a small city, for weeks, orchestrated by software you’ve never installed on your iron. Pretraining — predict the next token, repeat until the statistics congeal. Fine-tuning. Preference optimization. Reinforcement from human labelers, or from other models, or from “verifiable rewards” in whatever script kiddie dialect the lab invented last quarter. Checkpoints the size of a filesystem you don’t own. Ablation studies you’ll never see. Failure modes buried in internal dashboards.

Researchers call most of the big ones black box AI: inputs and outputs visible, the hidden layers in between not interpretable even to many of the people who shipped the thing. Open-science efforts like OLMo try to break that — publish data, code, logs — and God bless them; it’s still not the same as popping the case off an XT in 1993.

As a SysOp, I hate this. My communion was always know, verify, own. Training is the opposite pole: trust the temple builders and the algorithms they built, hope the coin lands text-side up, and accept that the process that minted the oracle is opaque by design.

The communion changed.

It used to be: learn the language, speak precisely, verify the output, own the failure. rm with sufficient privilege really does remove things. The machine doesn’t argue. It doesn’t confabulate. It doesn’t flatter you.

Now it’s: speak in human, and something probabilistic assembles an answer that looks like knowing. Sometimes it is. Sometimes it’s a confident collage. The Iron God has become an oracle that read a billion scraped pages and still can’t tell you, with certainty, which hop dropped your packet last Tuesday.

I’m not saying that’s worthless. I’m using it. You’re reading the proof. But it’s a different covenant:

• The old gods demanded rigor; this one rewards fluency.
• The old gods failed loudly; this one, that calls itself Intelligent…even if artificial… fails plausibly.
• The old gods lived in rooms you could badge into; this one lives… everywhere, and nowhere, and in whatever cloud region was cheapest five minutes ago.

I miss the clarity of “that command returned exit code 1.” I don’t miss every 3am page. Both things can be true.

Speaking to run the machine

There’s a strange loop here that would have sounded like cyberpunk nonsense in 1993:

Speech → model → agent → Cursor → markdown → Hugo → rsync → another Iron God on a host named like a moon of Mars.

That last hop is DotBlag, off to the left outside of your browsers viewport. The chain above is how a post like this one gets from my mouth to your browser. Whether the Iron God at the end of the rsync is really on something that counts as a moon of Mars — and whether that counts as a moon — is the same circus as Pluto’s planethood: pedants, votes, nobody convinced. Astute readers can grep the workflow on Pluto’s planethood if they’re bored. I am not taking comments on this.

The architecture that actually moved is entirely the top of that chain, not the bottom. Nesting deeper again. Building on shoulders, raising up giants, but built on so much other work. Just like a lowly BBS and it’s door games and message boards. DotBlag has never been a purity contest — there were always middlemen. You just pick which ones get to ruin your afternoon.

For a very long time it was WordPress: themes, plugins, comment spam, upgrades that pray to a white screen, and the creeping BOFH realization that you’re not running a blog — you’re running a small PHP hospice that eats Tuesdays. It worked until it didn’t. When the “content management system” needs more nursing than the content, a Bastard Operator starts looking for firewood.

So DotBlag moved to Hugo. With the words typed into an SSH terminal with vi, built with entirely Human Hands into markdown — but even there Hugo is the middleman that turns that into static pages before anything rsyncs anywhere. Honest middleman. Predictable middleman. The kind that doesn’t page you because a plugin author went on holiday.

Now the top of the stack moved again: DotBlag, at least for this Blag, goes through Cursor. You speak, a speech model listens, an agent reaches into tools and shells, and you fight the diff instead of living entirely in :wq. This post is being written through that hinge; yes, including where DotBlag lands when the build finishes, which is the sort of detail that leaks out when the machine reads your repo and your voice in the same breath.

From Hugo down it’s the same sysop tail — Forgejo Actions where GitLab CI/CD used to pray, if you need a label for the mess that actually converts this into something the webserver delivers — build, rsync, done. Not the sermon. The communion changed upstairs.

SysOp → DevOps → prompt writer

The job title on the door keeps changing. The person behind it — SysOp at the bone — doesn’t, not really.

SysOp (especially on a BBS) meant you were the machine’s local priest and bouncer. You dialed in (or hosted) the forum. You moderated flame wars. You clubbed cave trolls, sometimes with great glee….ok who am I kidding, usually with absurd amounts of glee… You knew where the files lived and who got how many kilobytes of download. The 2022 piece already admitted the wider wardrobe: sometimes you were the admin, sometimes the SysOp, perhaps The Network guy. And sometimes — speaking truthfully — the Bastard Operator From Hell. BOFH: Simon Travaglia’s fictional rogue operator, born in late-1980s university ops boredom, weaponized on Usenet in the 1990s, and still stalking the industry through The Register like a cautionary folktale. Not a compliment. Not always wrong, either. BOFH is what your peers call you after the third ticket that could have been fixed by reading the error message.

DevOps was the next sticker on the door. Same keys, same stick, different liturgy: pipelines, containers, infrastructure-as-code, “immutable” servers that still break on Tuesdays. You still convene with the Iron Gods — you just do it through YAML and a CI runner instead of AUTOEXEC.BAT and a modem screech. The sharks learn new words; the dragons move from badge raids to cloud policy. You’re still the one who knows the stack, still the one they call when the site is down and the board room wants a miracle in plain English.

Prompt writer (or “AI engineer,” or whatever HR prints this quarter) is the latest costume. Natural language as the front panel. Microphone as stdin. You don’t less often fix the problem by typing commands into your shell — you describe the problem to an oracle and hope the agent invokes the right tool. Your .cursor/rules file is a kind of rc.local for a model you don’t host. Your “deploy” might be a commit you asked for in chat. Your near-misses include the automation pushing to origin when you only wanted a local diff. (We added a rule for that. Good.)

I’m a SysOp. I always was. Some days the org chart says DevOps. Some days the job is prompt writer. Some days I’m BOFH in my head, and I try not to let it leak into the ticket queue. SysOp used to mean knowing where the serial cable went. DevOps meant you could reproduce the temple from a repo. Now it sometimes means curating prompts and verifying that the machine didn’t confabulate your production away. Different rituals. Same covenant — if you can keep it.

The dragons are different too. Not only badge-and-raid dragons. Terms-of-service dragons. GPU allocation dragons. “Your account has been flagged” dragons. The hoard isn’t secrets in a /etc you weren’t supposed to read — it’s weights you’ll never download, CI secrets you can set but never recover (paste it wrong into GitHub or Forgejo once and don’t save the correct version in 1Password — it’s gone; reissue and rotate), and policies that change on a blog post.

And the sharks? Still in the board room. But now they’re also on the cap table — the ownership roll — of whatever lab shipped the model, and they’re very excited about margins per token while the AI Burst is still inflating. The bubble may be peaking or popping; the winter will come back as it always does. That doesn’t make the coin less dual-use. It makes the priests louder while the offering plate is full.

The same coin (not command-and-control — the whole thing)

I’m not fixated on AI wired into nuclear launch systems. That’s a real policy argument, but it’s not the knot in my gut.

What keeps me up is looser and bigger: AI as the digital, cyber-age analogue of nuclear-level power — not “a nuke in a rack,” but a technology whose misuse can scale harm the way fission scaled harm once the world learned what a chain reaction meant.

And like fission, it’s one coin with two faces.

On one face: horrors. Surveillance at scale. Deepfakes as political munitions. Automated cruelty in bureaucracy. Wars of attribution where nobody can tell who pulled the trigger because the trigger was a pipeline. The Centre for Future Generations frames advanced AI and compute plainly as dual-use: the same chips and clusters that tutor a kid can train systems you do not want your enemies to hold.

On the other face — from the same piece of “metal,” if you’ll forgive a SysOp stretching a metaphor — we got the rest of the nuclear story too. Medicine. Power grids that don’t burn coal for every watt. Food safety. Science that could not exist without tracers and tools born from the same era as the bomb. A PMC review drawing parallels between nuclear energy and AI development notes both rose from deep theory into civilization-scale infrastructure, with ethical and geopolitical fights trailing the physics (Back to the future – from nuclear energy to AI).

AI rhymes with that, not only with the mushroom cloud. The Iron Gods always had a destructive read and a constructive read. Punch cards and weather models. The ARPANET and the same labs that incubated a lot of what became “cyberwar” in the popular imagination. One substrate; which face lands up depends on who holds the coin, and what incentives they answer to.

That’s what scares me. It’s not that speech-to-text launches missiles by itself — it’s that speech-to-text plus a model plus an agent plus a Friday deploy can absolutely get you there, especially if someone gave the agent a shell and called it “productivity.” “Launch missile” is one homophone, one over-eager tool call, and one BOFH on call who assumed the transcript was a joke. The warhead was always the integration.

What keeps me up is bigger than hot-mic accidents: we’re building nuclear-class leverage in software — knowledge amplification, persuasion, automation of trust — and the early holders are exactly the profile that flipped the last century’s coin wrong often enough to leave scars: a handful of powers, public and private, racing each other while telling the rest of us to stay calm.

There’s a proclivity of mind that fits that phrase too well: we trust algorithms over humans. The pop story is that people are skeptical of machines; the experiments often show the opposite for lay judgment — identical advice gets taken more seriously when people think it came from an algorithm than from another person. Researchers call that algorithm appreciation (Logg, Minson, & Moore, 2019). SysOps have had an older, uglier label: automation bias — over-relying on automated output, commission errors when the automated advice is wrong, vigilance that rots because the box sounded confident (Goddard, Roudsari, & Wyatt, 2012, systematic review). The literature isn’t one-note — algorithm aversion shows up too once people watch a model blow a forecast (Dietvorst, Simmons, & Massey, 2015) — but the drift right now isn’t arguing with the machine. It’s nodding along because the paragraph is fluent and the human in the loop is tired, or a few too many Bayern Dump Truck’s in to GAF.

Energy makes the metaphor uglier

The rhyme gets sharper because AI is eating energy the way the nuclear age ate uranium and steel and political attention.

Hyperscalers are signing decades-long deals to restart reactors, build behind-the-meter islands, chase “energy sovereignty” — because a training run is industrial load, and inference at scale is a city that never sleeps (overview of AI–nuclear convergence; energy sovereignty framing). Same metal, same wires, same fight over who gets the baseload.

So it’s not just “dangerous math in the cloud.” It’s the cyber equivalent sitting on the physical equivalent, and both concentrating in the same few hands.

If only the powerful hold the coin

If only the powerful control this — states, hyperscalers, whoever can afford the temple — the coin flips toward evil far too easily. Not because everyone at those tables wakes up evil. Because power preserves power. Because “safety” becomes a moat. Because the good face of the technology gets licensed back to the rest of us as a product, on terms, with kill switches.

We already lived a version of this. Nuclear knowledge did not stay in Los Alamos as a shared civic trust. Neither did the early internet stay a place where SysOps and researchers and weirdos built in the open because it was fun and true. The dragons and sharks adapted. They always do.

I want the good face. I want greatly increased human knowledge, the way cheap access to iron gods once let a kid with an XT learn the world. I’m speaking into an AI right now because the communion still exists — it changed form, not desire.

But I don’t trust a coin that only mints in Silicon Valley board rooms and security-cleared briefing slides. Distributed SysOps mattered for the old gods. They matter more for these.

What I think I’m mourning

Maybe it’s not the XT. Maybe it’s the legibility.

I could read the BIOS POST codes. I could watch link lights. I could tcpdump a conversation and see the communion happen. The new Iron Gods are friendly and verbose and sometimes brilliant — and the trail from my prompt back to their training run is a locked door chain longer than any datacenter aisle I ever walked.

I still want to build. I still want to SysOp. I still want the word to be truth. But the temple architecture changed while I was busy with other life — $dayJob, planes, stars, the ordinary human stuff.

So this is another installment in a poem I didn’t know was a series — one I finally parked on DotBlag in 2022 after carrying it around for years I can no longer date. I’m speaking into an AI to write about speaking into AIs, and somewhere in Silicon Valley — or Virginia, or Oregon, or a leased rack in Phoenix — an Iron God hums and answers.

I tip my hat to the SysOps, who still Behave, still Deliver what they Promised, still verify before they trust — including myself, when I remember to.

The rest of us SysOps should probably do the same, even when the oracle sounds confident.