Confessions of a reluctant Luddite

I had a moment this week where I genuinely considered becoming a Luddite. Not in a dramatic, delete-all-my-accounts way. In a proper, roll-up-the-sleeves, gather-the-villagers and smash the machinery sort of way.

Because I realised something slightly unsettling.

I am in a new Industrial Revolution, and I am the one weaving the textiles.

Last time I wrote here, I was still comfortably speculating that the change in my job was coming “soon.” Soon is a wonderfully stretchy word. It gives you room. Soon can mean next year. Soon can mean after the next roadmap. Soon can mean once everyone else has figured it out. Now it just means today.

I’ve been working with the latest generation of AI models recently. Not here to start a pub brawl about which brand is superior. What matters is the step change. The jump from “helpful autocomplete with good manners” to something that feels like a suspiciously competent colleague who has quietly read your entire codebase and formed opinions.

Large, complex parts of our system are becoming easy to modify. And that word, 'easy', feels like a betrayal.

This is a codebase that grew the way coral reefs grow. Slowly. Layered. Accreted through time and compromise. It contains old architectural ideas, half-finished refactors, comments marked “temporary” that have survived multiple federal governments. Changing it used to require care. You didn’t just edit a file. You negotiated with history. You reasoned through side effects. You felt your way through it like someone defusing a bomb built by your past self. That was the craft.

Writing code wasn’t just output. It was the thing. The careful but clumsy naming. The shaping of a function so it read cleanly. The quiet satisfaction of refactoring something awkward into something almost elegant. You chase a kind of singularity of perfection that you never quite reach, but you enjoy the pursuit. You refine that over decades. You build a career on it. If I’m honest, you build a bit of your identity, your “being” on it.

And now I can describe a change in English in a simple prompt, hand it to a small pool of AI agents, and they go off like diligent mill workers. They update functions, adjust tests, restructure modules, and return with a pull request and a tidy summary of what they did and why. I review. I merge. I move on.

It feels like I’ve been hand-weaving textiles for years, obsessing over thread tension and pattern symmetry, and suddenly someone wheels in a steam-powered loom. Not just any loom, either. One that reads your sketches, suggests improvements, fixes your inconsistencies, and doesn’t get tired. I am still in the factory. But I am no longer holding the shuttle.

That’s the Industrial Revolution part. Not in a smoky Dickensian way. There are no soot-covered children and no factory whistles. There is just a quiet shift in who does the weaving and at what speed.

Part of me is genuinely thrilled. I have always loved new technology. I was the kid mesmerised by a CD-ROM encyclopaedia because it had moving pictures on a screen that wasn’t monochrome. Later I was burning my own CDs like some suburban DJ convinced I had bent the universe to my will. New tools have always felt like magic to me.

But magic hits differently when it starts absorbing the part of your craft you loved most.

I didn’t expect to feel a small grief about writing code. Yet here it is. The act itself, the slow shaping of logic, the wrestling match with a tricky bug, the quiet flow state of getting something just right, that was arguably the most fun and creative part of the job. The bit I’ve spent decades refining.

Now I spend less time writing and more time describing. Less time implementing and more time directing. The creativity hasn’t vanished, but it has moved up a level. It’s in the framing of problems, the clarity of instruction, the judgement about what should exist at all. When code becomes cheap, judgement becomes expensive.

And that is both exciting and unnerving.

There is a part of me that wants to gather a small band of romantics and smash the machines. To insist that craftsmanship matters, that hand-written code has soul, that we will not surrender our looms without a fight. But this is not 1812. The machines are not in a shed down the road. They are in global data centres the size of suburbs. You cannot smash them. You can barely conceptualise them.

So the Luddite fantasy fades quickly into practicality.

The real shift is not that I am being replaced. It’s that my role is dissolving and reforming around me. I am less the carpenter and more the foreman of a factory floor full of robotic arms. They are tireless, context-aware, occasionally wrong but fixable in minutes. They do not care about the poetry of a well-named variable. They care about producing output.

If I zoom out, this is exactly what an Industrial Revolution looks like. The skill doesn’t disappear. It gets abstracted. It gets scaled. It gets embedded into machinery so that fewer people need to practice it directly.

We will, of course, handle this badly. We will measure success by pull request volume. We will generate more code than we can sensibly own. We will confuse velocity with value because the graphs look impressive. We will industrialise the wrong parts first, because that is our particular gift as an industry.

The turning point has already happened for me. The change I thought might take another year or two is in my repo today. My job is not vanishing, but the part I loved most is being quietly automated away.

I am still excited. I am still that kid staring at a glowing screen thinking this is magic. I am just also aware that I am no longer weaving every thread myself. And if history tells us anything, it’s that we are about to do software wrong on a scale previously reserved for textiles.