The Half-Life

In 2018 I started spending my evenings buying certainty.

Tens of courses, all out of my own pocket, watched after work once the house had gone quiet. Angular, the 2+ rewrite that threw out everything AngularJS had taught us, was simply the thing I had decided I wanted next, and nobody was going to hand it to me during office hours.

By 2021 it was fluency, driven toward perfection. The core of the framework had long since stopped costing me thought; the experience ran deep enough that I was fine-tuning even something as marginal as mixins. They chained factory into factory, each one taking a base and handing back something wider, the chain bottoming out in an empty class that existed only to be the floor.

mixinUnsubscribe(mixinColor(mixinDisabled(Base)))

From memory, at speed. The unsubscribe one was mine, so nothing we shipped could leak a subscription on destroy. In eight years I have met exactly one other developer who wrote them that way.

What I felt about that skill wasn’t ambition. It was safety. This one, I thought, I will be using for years. Undoubtable.

The arithmetic

The casualties come to me without effort. Hand-written actors, ported from languages that had them properly. Callback pyramids, then the promise chains I learned in order to escape the pyramids, then async/await, which retired most of the chains in turn. A rescue technique that needed rescuing.

None of that is a complaint. Learning the next thing is the job, and anyone expecting one skill to feed them for thirty years misread the contract.

But run the pattern forward and it looks bleak. If the shelf life of what I am hired for is roughly five years, nobody over thirty-five should have anything left to sell.

And yet the most employable people I know are the ones who have been doing this longest. So the arithmetic is wrong somewhere.

The night I built it myself

In 2024 I put a model on my home server.

My laptop had no dedicated GPU, so anything serious was never realistic there. The server did. I cloned the project, followed its README, built an isolated Python environment inside WSL, pulled down dolphin-mistral. Setup took about an hour. None of it was hard, which is the part worth noticing: it drew only on things I already knew how to do.

I told myself I had built a private Google. One home server and one GPU is no match for a search engine on speed, and I did not care in the slightest: nothing I asked it ever left hardware I owned, and unlike a search box it held the thread of what we had already said.

Then I found the Python libraries that let me stop typing at it and start talking to it. Calling the API, getting an answer back in a voice. Slower than it would be today. But I was sitting with earphones on, holding a conversation with a machine in another room, hardware I owned, and every part of it had been wired by me.

Science fiction, by any standard I grew up with.

Then the second feeling arrived underneath the first, quieter and much worse. I had used every skill I was proud of to build the thing that made me wonder whether the skills still counted.

The part I keep returning to is the GPU. My own machine could not do it. The model ran elsewhere and I reached it over the network.

The knowledge had stopped being resident. It had become something I query. I built that in hardware two years before I noticed it had already happened inside my head.

Nothing actually died

Almost nothing on that casualty list is dead.

RxJS ships today. Java streams ship today. SCSS loops, T-SQL built-ins, lodash, server-sent events, the Docker images I still write and publish: all alive, all still shipping. I used to know dozens of RxJS operators by heart, and I still use RxJS constantly. I just don’t hold all of them any more, not in that detail, and it costs me nothing.

The technology didn’t expire. My recall did.

That is the whole story. What got automated was never the engineering. It was the lookup table I had mistaken for engineering, the part that looked like sorcery from outside: instant, effortless, a layer running underneath the visible one that I could read and most people couldn’t.

Reading it was never the same as deciding. A model can recite all seven of Spring’s transaction propagation levels perfectly, and always could. Choosing which one wraps a money transfer, and knowing what the rollback does to the audit row underneath it at two in the morning, is a different organ entirely.

The answers nobody wrote down

Later I sat inside a rewrite that should not have worked. A legacy monolith, a deadline expressed as an Excel table, behaviour that nobody on the team could fully explain, including me. Documentation existed, but there was little of it and it had stopped matching reality years earlier. What we had was the code.

We learned what the system meant while writing the thing that would replace it. New technology, tighter design, fewer bugs, better numbers, against a date that did not move.

None of that was recall. It was reading a situation. Which behaviour was load-bearing, and which was an accident committed years ago that everyone had since learned to walk around. Which bug had been in production long enough that people now depended on it. When to go and ask, and when asking would cost more than deciding.

None of those answers existed as text until we worked them out. Not in a wiki, not on Stack Overflow, not in any corpus anyone has ever trained a model on.

About that ladder

The fair objection: judgement like that comes from years of grinding the basics, so automate the basics and nobody can build it. The ladder is gone.

I don’t think the basics ever built it. Mine came from being thrown into the deep end as a junior, on an insurance system serving tens of thousands of people, with no sandbox and every commit going straight to production. I learned fast partly because I wanted to and mostly because I had to.

What made me useful was never the looking things up. It was carrying weight slightly before I obviously deserved to.

That road is still open, and arguably wider, because the tax that used to eat a junior’s first years has collapsed to almost nothing.

What hasn’t changed is that somebody has to hand you the weight. If a rung is disappearing, that is the one, and removing it is a decision people make, not something the technology did.

Be precise about which of those you are actually afraid of.

What compounds

I played trumpet for eighteen years, from the age of five. Arban études drilled until they were mine, and calluses on my lips to show for the hours. I don’t play now, and none of it was wasted, because the trumpet was never the asset.

What transferred was everything standing around it. Hearing that something is slightly off before I can explain why, the way you know a note is flat before you can name the interval. Showing up on the days I don’t feel like it. Being willing to be visibly bad at something until I’m not.

That survived the instrument. It survived AngularJS. It will survive this.

So stop defending the part a machine does better. You will lose that race, and it was never where your value lived. Go and stand where the consequence is. And keep reading the diff before you run it, because the same fluency that lets you build quickly is the only thing that lets you catch what is wrong.

If you are in the middle of this and it is keeping you up, I would rather you asked me than sat with it alone. That is what my inbox is for, and not only for work.

You are not obsolete. Your lookup table is, and you were always considerably more than your lookup table.

The ground will move again; it always does. The only question is whether you intend to be standing on the new one before it gets crowded.

Nobody has ever been made redundant from a reflex.