TL;DR
Once AI can turn a clear description into working software, the line that matters is between building and using, not between people who can code and people who can’t. I think bespoke, short-lived tools will explode, products will hold wherever people want someone else accountable for the result, and judgment becomes the scarce skill.
At some point, AI is going to get capable enough that creating detailed, complex, use-case-specific software takes little more than a clear description of the problem. One prompt, or a short series of them, will be enough to produce something functional, tailored, and immediately useful. The traditional barriers (time, specialized skill, and cost) will largely collapse for many kinds of software.
That raises a natural question: what happens to software products when building software becomes an ordinary step in someone’s job rather than a distinct professional activity? I don’t think the answer is that commercial software disappears. The way I see it, the landscape splits more sharply than most people currently expect, along the line between building and using.
The Difference Between Building and Using
There’s a meaningful distinction between the ability to create software and the desire to own it. Building something means accepting responsibility for whether it works correctly, produces the right outputs, handles edge cases, stays secure, and keeps functioning as conditions change. Using something means consuming a finished capability whose ongoing correctness, support, and risk are someone else’s problem.
Many people who could build will still prefer not to. They won’t want the cognitive overhead of specifying, verifying, and maintaining a tool, even if the act of generating it becomes trivial. They won’t want to be the person who has to explain why the numbers are wrong or why a process failed. For those users, a reliable product with clear ownership, support, and accountability will stay more attractive than a personally generated alternative, no matter how easy that alternative becomes to create.
To be clear, this preference isn’t primarily about technical skill. It’s about risk, attention, and the division of labor. Most knowledge work already involves using specialized tools rather than constructing them. AI will expand the set of people who can construct tools; it won’t automatically expand the set of people who want to own them.
Where AI Takes Over: The Bespoke Layer
I expect the most immediate and significant change to land in the space of highly specific, low-volume software. Plenty of useful tools have never existed as commercial products because the addressable market was too small. The requirements were too particular to one person’s workflow, a single team’s process, a narrow regulatory context, or a temporary project. The economics never justified a company building, selling, and supporting them.
AI changes those economics. When the marginal cost of creating a nuanced tool approaches the cost of describing it, individuals and small teams will simply generate the software they need. Those tools will often be tightly fitted to a specific context: a custom analysis pipeline for one analyst’s data sources, a reporting layer that matches exactly how one manager thinks about their numbers, a lightweight system that encodes one organization’s peculiar combination of policies and exceptions. In many cases they’ll be short-lived by design, useful for a project or a season, then discarded or regenerated when conditions change.
Most of this layer will never appear in app stores or enterprise catalogs. It will exist as personal or team infrastructure, created on demand and owned by the people who use it. Its defining characteristic is that it’s valuable precisely because it isn’t general. The more idiosyncratic the need, the less likely it was ever going to be served by a mass-market product, and the more likely AI-generated software fills the gap.
I’ve said for a while that network engineers shouldn’t fear automation taking their jobs; they should fear someone else using it. The bespoke layer is that same idea at a bigger scale. The advantage goes to the people who accept that these tools are here and choose to build the small, specific ones their work actually needs.
What Remains in the Product Space
Commercial software products won’t vanish, but I think their role concentrates around capabilities where the distinction between building and using matters most. Products will keep existing where users want standardized behavior, ongoing maintenance, broad interoperability, and clear external accountability. They’ll also persist where the cost of getting something wrong is high enough that people prefer a vendor who stands behind the result.
In the enterprise, this dynamic is especially durable. Risk management, compliance, audit requirements, and liability considerations will keep favoring purchased software for many functions. Organizations will often prefer tools whose behavior has been validated across many customers, whose security posture is contractually supported, and whose failures can be escalated to a vendor rather than attributed to an internal prompt. Even when an internal team could generate an equivalent system, policy and process will frequently prohibit it. That decision won’t be driven by technical feasibility; it’ll be driven by the institutional preference for external ownership of certain risks.
Products also keep their advantages in areas that benefit from network effects, large-scale data, continuous improvement across a wide user base, or deep integration with other systems. A tool that improves because thousands of organizations contribute usage patterns, or that has to interoperate reliably with dozens of other enterprise systems, still has structural reasons to exist as a maintained product rather than a collection of one-off generations.
Implications and Open Questions
So the result, as I see it, isn’t a single future in which software either becomes free or stays expensive. It’s a bifurcation. On one side sits a large and growing volume of bespoke software that would never have been built under the old cost structures. On the other side sit products that keep existing because someone still values the separation between the person who uses a capability and the party responsible for its correctness.
Several tensions follow from that split. Verification and evaluation get more important as generation gets easier; the hard problem shifts from writing the software to knowing whether the software that was written is the right one. Maintenance patterns change when many tools are expected to be regenerated rather than evolved. Organizational boundaries around what may be built internally versus what must be purchased become more explicit. And the skills that stay scarce are less about implementation and more about judgment: knowing which problems are worth encoding into software at all, what “correct” looks like in a given context, and when the responsibility of ownership is worth accepting.
None of this requires AI to be perfect. It only requires AI to be good enough that the cost of producing a tailored tool falls below the threshold at which most people or organizations would bother to commission one from a specialist. Once that threshold is crossed, the difference between wanting a capability and wanting to own its construction becomes the more important variable.
So no, I don’t think the future of software is the disappearance of products. I think it’s the expansion of a parallel layer of highly specific tools that exist because individuals and teams can finally afford to create them for themselves, and the continued existence of products wherever people would rather someone else stay responsible for the result.

No responses yet