THE VOICE IN THE MACHINE

What happens when anyone can build software, and where the value goes once building is free.

I happened to listen to a February 2026  interview with Mark Cuban on the Technology Brothers podcast and he stated very boldly: “Software is dead because everything’s going to be customized to your unique utilization.” This is the kind of line that travels fast: confident, a little apocalyptic, and delivered by a man who made his first fortune building and selling exactly … software. The software ETFs dropped, the clip went around, and a good many people repeated the sentence as though that is settled.

Really? I want to take the claim seriously, because someone who has spent a career inside this industry is not saying something careless when he says it is over, and because the instinct behind this provocation makes sense, in a way. Yet the word dead hides the more interesting truth, and I believe the conclusion he draws is worth arguing with.

So let me begin by stating that software is not dead, not yet. Yes, it is dying, and the difference is not pedantic, because dead names an event while dying names a process. We are living inside that process rather than looking back on its conclusion. But, I would argue, that what is dying is not software as such but one particular thing the term refers to: software as the artifact a person laboriously writes and painstakingly maintains. Today almost anyone can build an application, including people who had never written a line of code until yesterday. And they can do that by describing what they want to an AI model, in English or in one of many other world languages, and letting it assemble the rest. However, much of what gets built that way will be disposable, regenerated from scratch on a whim rather than corrected and kept. And, honestly, a fair amount of it will simply be junk. That is real, and it is the grain of truth in Cuban’s statement.

But if building software has become practically free, except for the tokens you have to pay to Anthropic or OpenAI, the question that actually matters is not whether the software as we knew it yesterday dies. It is where the value goes when the hard, scarce, expensive thing stops being hard, scarce, and expensive. Scarcity, in these epochal transitions, like the one generated now by the AI explosion, behaves like a conserved quantity; it rarely vanishes, it moves, and the whole game is finding where it went. My collaborator Pierangelo Raiola frames a companion version of this in The Gauss-Cauchy Arbitrage, where the opportunity lives in the gap between how fast capability arrives and how slowly the economy absorbs it. Cuban has an answer, and it is a good one: the value, he says, moves to the people who can translate the technology for the thirty-three million companies that will never have an AI department, the integrators rather than the builders. I think he is pointing in the right direction, but stopping several steps too soon.

The point is not about just building software, but building software that answers a real need. That is a different and much harder task. Anyone who has watched a beautifully engineered product die in the market knows that engineering was almost never what failed. So the natural conclusion, and it’s the one many people are finally reaching, is that the value has shifted from building to knowing what to build. But that answer is still incomplete, because it conceals a distinction that turns out to decide everything: whether the need can be read.

In consumer markets the need can be read, and thus cheap building really is the good news everyone says it is. There will be plenty of roadkill in the free-for-all of app building, but that is the price to pay when everyone can write software. When you can ship an application in an afternoon, you can put it in front of real people, watch what they do rather than what they say, and let their behavior tell you whether that is what they actually wanted. Build fast and fail fast is the key. The market becomes an instrument that reads the need for you, slowly and expensively but reliably, and the collapse in the cost of building simply shortens the loop between a guess and its correction. Even a builder who fell in love with the wrong idea gets dragged toward the right one by the data. This is the world most of the excitement describes, and that excitement is earned.

Then there is the enterprise, and inside the enterprise the instrument breaks. Why does it break? Because the feedback loop that reads the need in a consumer market does not exist inside a single organization. There is no anonymous crowd whose behavior you can measure at scale; there is one particular company, with its own history, its own exceptions, its own quiet understanding of who may approve what and why last quarter’s unusual case was handled the way it was. Almost none of that is written down. It lives in the heads of the people who do the work, in habits and judgments no one has ever had reason to make explicit, and it is often invisible to the whole organization itself. You cannot ship a quick version and let the market correct you, because there is no market, only a single hard-to-read context that has to be understood before anything you build can possibly fit it. The need is entirely real, and it is illegible, and building software cheaply does nothing to help you read it.

Two years before Cuban, Satya Nadella told the same kind of audience that business applications would collapse in the agent era, because underneath they are little more than CRUD databases wrapped in business logic, and that logic, he argued, would migrate out of the software and into the agent tier. The press shortened this to “SaaS is dead,” though that is not quite what he said. He is right that the logic moves. But notice what the migration does not touch. The logic that lived in the software was always the legible part, the part someone had already troubled to write down. What never made it into the database is who may approve an unusual case, why last quarter’s exception was allowed, which rule is load-bearing and which is merely habit. Those hidden things are exactly what the agent now needs and cannot find, because it was never anywhere but in the heads of the people who do the work. Collapsing the backend does not surface that knowledge. It removes the last structure that was pretending to hold it, and leaves the company face to face with how little of itself it has ever made explicit.

This is where the value actually is now, and it is a step beyond where Cuban stopped. It did not go to the people who can build, because building is precisely what became free. It did not even go to the people who know that one should build for a need, because inside the enterprise that advice is true and useless in the same breath. It went to whoever can make an organization legible enough that the need becomes visible and can then let a machine act inside that organization while being trusted to do so. That act of translation, as I described it in my series of essays from Spark to System, in other words going from an opaque human context into something a machine can operate within safely, is still the scarce thing now, and it is scarce in a way a mere services layer is not, because it compounds. Every workflow you make legible teaches you how to read the next. It is the part no model performs natively, however fluently it writes code, for the simple reason that the model has never met your company.

We are told that technologists fall in love with their solutions instead of their problems, or that they build solutions in search of a problem, and we are told it as though it were a moral failing. It is nothing of the kind. The solution is simply the only thing they can actually see: legible by construction, something you can hold up, demonstrate, admire, and refine, while the problem lives inside someone else’s context and is frequently invisible even to the person who owns it. The discipline of the coming decade, the one I would bet a career on, is the work of making problems as legible as solutions have always been.

So is software dead? No. But the era in which writing software was the hard part is ending, and what comes next will reward the people who can read an organization more than the people who can build an app. That is a smaller claim than Cuban’s, and I believe a truer one. And in my wildest dreams I go one step further than both him and Nadella. I imagine a time when software, as a distinct thing, is no longer necessary at all, because the model itself — a neural network, today a large language model and someday perhaps something we have not built yet — does natively everything software does for us today: it holds the state, it performs the logic, it reaches for tools that are themselves models. We are not there, and today none of this is true. But I think we will get there.

And here is the part that matters: even then, the machine will still have never met your company. It will still have to be told what the work is for, and that knowledge will still live in people. That is why the prospect of the machines needing us less does not worry me. The one thing they cannot supply, at any level of capability, is an organization that has understood itself well enough to say what it wants. We keep treating that as a problem technology will eventually solve. Technology never touches it. It is the work of a company learning to read itself, and that work is only beginning.

Cuban’s remark is from an interview on the Technology Brothers (TBPN) podcast, February 2026.

Nadella’s is from the BG2 podcast with Brad Gerstner and Bill Gurley, December 2024.

Pierangelo Raiola’s The Gauss-Cauchy Arbitrage is at https://pierangeloraiola.substack.com/p/the-gausscauchy-arbitrage.