For most of the history of the software business, the thing being sold was the artefact. That era is over, and the change matters for anyone who buys or builds software for a living.
How the artefact was priced
In the 1980s a copy of a program was a product in the ordinary sense. A programmer could write a game, place an advertisement, and sell the cassette for a fair price. The buyer received something, the author was paid, and the transaction made sense to everyone involved.
The 1990s strained that model but did not break it. Piracy was already widespread, and yet substantial companies, from compiler vendors to operating-system publishers, were built on the premise that code in itself was worth paying for.
The 2000s introduced software as a service, and the floor began to give. By the end of the 2010s the price of code as an artefact had fallen close to zero. A few independent developers still sold packaged software successfully, but they were survivors of a category that had largely disappeared.
What SaaS actually did was relocate the price. It moved from the code to the service around the code: uptime, patches, backups, the database recovery at three in the morning. For a business customer this was a better arrangement. Nobody wanted to own the floppies. They wanted the outcome.
What AI did to the price
As of 2025, the price of code as an artefact is not zero. It is negative.
That is a precise claim. It is now more expensive, in token cost, maintenance burden and the effort of keeping a model on task, to maintain a large, carefully documented codebase than not to have one. Models still struggle with very large legacy systems; nobody is regenerating a million lines of enterprise Java in an afternoon. But for small and mid-sized systems, a competent engineer with a modern model can reproduce almost any product you could name in a working day. An open-source project can be cloned in hours, sometimes with better organization than the original.
The usual objections are correct and do not change the conclusion. Tests, observability, migrations that do not fail at nine in the morning, all of it is still required. It is also now largely generated. Hand the existing test suite to a model, ask for the rewrite, and it works.
The consequence is that there is no meaningful intellectual property in ordinary application code anymore. There has not been for some time. What has changed is that it is no longer possible to pretend otherwise.
What this means for the "10x engineer"
For a brief period the industry believed in the ten-times programmer, a person worth a finder's fee and a war room. That role has not been eliminated. It has been made ordinary. Any well-trained engineer who understands the fundamentals, can lay out a system, and is willing to work with a model can now ship in an hour what the celebrated engineer of 2010 produced in a week. Not because they are exceptional, but because the floor moved.
Where the value went
It went where it has always been. The question every business has faced for the whole history of commerce is the same: what can you do, who needs it, and how does that need become revenue. The industry spent two decades treating the artefact as the product because the artefact was hard enough to make that it could be charged for. It is not hard anymore, so we are back to the fundamentals.
There are a great many businesses with real customers and real cash flow running their operations on a forty-tab spreadsheet that one employee maintains by hand every Monday morning. That spreadsheet is a problem someone could solve. Not by writing software, because software is now the cheap part, but by understanding the business well enough to put the right system in front of it, and by taking responsibility for that system once it is running.
That is where the engineer of 2026 is useful, and it is how this firm positions itself. The code is the easy part. It always was. It was simply hard enough, for long enough, that it obscured the work that actually mattered.