Long, long time ago, when the computers were big and we were young and full of thoughts of a brighter future, you could sell a copy of computer software for a fair share. It was profitable. It was definitely profitable in the 80s — a kid could program a game on his Spectrum or his C64, take out a quarter-page ad in the back of his local paper, and sell the cassette for $10 a pop. The whole transaction made sense to everyone involved. The kid wrote something. The buyer got something. Money changed hands. Capitalism, in one of its more wholesome forms.
By the 90s the same logic was already getting strained, but companies were still making serious money off shrinkwrap. Borland, Microsoft, the entire tail of mid-tier tooling — actual businesses built on the premise that code, in itself, was a thing worth paying for. Listen — even then, the world was already full of pirated software (and still is, let’s not pretend that’s a 2025 problem). And yet, somehow, you could still make money off your code.
Then the 2000s rolled in with the first SaaS plays, and the floor started to give. Slowly at first. By the end of the 2010s, the price of code had basically plummeted to zero. A handful of indie game devs were still out there selling actual artefacts — Stardew Valley, Undertale, the usual suspects — but they were the survivors of a category that had been quietly cremated for the rest of us.
What SaaS actually did was move the price tag. Not from “expensive” to “cheap” — from “the code itself” to “the service around the code.” Which, honestly, is a much better arrangement for a business. Hand over the login and password, the vendor handles uptime and patches and the 3 AM database recovery, you get on with your actual job. Nobody was buying floppies anymore. Nobody had to.
That was more or less the deal until 2025.
And now we have AI. The price of code is basically negative.
Read that again. Negative. It is now more expensive — in token cost, in maintenance burden, in the cognitive load of keeping a model on the rails — to have a thoughtful, well-documented codebase than to not have one. LLMs are choking on context windows the moment you point them at anything resembling a real production system. The big ones still hurt; nobody’s vibing their way through a million lines of legacy enterprise Java. But small and mid-size code? Dead. A competent programmer with unlimited access to a 1M-context window can duplicate, in a single afternoon, almost any product you’d care to name.
There is no IP anymore. There hasn’t been, really, for a while — but now it’s just embarrassing to pretend otherwise. An LLM can produce a full functional clone of any open-source project in a matter of hours. Sometimes it’s even better-organised than the original.
(Yes, I know — we need to test and debug, we need observability, we need migrations that don’t blow up at 9 AM Pacific. I know all that. You’re correct, we do need all that. But listen, seriously? Take the old tests, hand them to an LLM, ask for the rewrite. It works. It’s not even slow.)
So this is the strange and slightly disorienting place programming has arrived at. The artefact is free. The artefact is less than free, because the artefact comes with maintenance bills attached.
It does not matter HOW you render your services. WHAT you provide matters.
We had a brief, weird moment in tech history when a 10x programmer was a thing — a person you’d actually pay a finder’s fee for. Recruiters chased them. Companies built war rooms around them. That’s over. We don’t need them anymore. Or rather: we already have them, in the form of any decently-trained programmer who knows the basics, can lay out a system, and isn’t allergic to typing prompts. Such a person, on a good day in 2026, can ship in an hour what the celebrated 10x of 2010 took a week to produce. Not because they’re brilliant — because the floor moved.
So where does this all leave us?
In the same place every businessman has lived for the entire history of business. How do you take whatever you can do, find someone who needs it, and turn that need into money. That’s the whole game. That’s been the whole game forever — we just spent twenty years pretending the artefact was the thing, because the artefact was hard enough to make that you could charge for it.
It isn’t anymore. So we’re back to the fundamentals.
There are still TONS of businesses out there with no idea what to do, struggling, leaking money out of seams nobody has bothered to look at. It’s 2026 and there are people running their entire operation in Excel — and, honestly, sometimes running it well. They have a real business, real customers, real cash flow, and a 47-tab spreadsheet that one person on staff prays to every Monday morning. That spreadsheet is a problem somebody could solve. Not by writing software for it — software is free now — but by understanding the business well enough to put the right thing in front of them.
That’s where the always-10x programmer of 2026 is supposed to go. Not chasing a recruiter’s note. Not optimising your LinkedIn for a job that’s already dissolving. Find the people who are already making money and help them make more of it. The code is the easy part. It always was — you just couldn’t see it, because the code was getting in the way.
You’ll be fine.