For most of its history, software was valued for what it did: the logic it encoded, the workflows it automated, the screens it organized. In the age of AI, that center of gravity is moving. When a model can write the logic and generate the screen on demand, what remains scarce is the data underneath, and the craft of presenting it so people can understand and act on it.
This essay argues that software and user experience are becoming, more and more, the presentation layer of data. Code is turning into a commodity, interfaces are turning fluid, and data is turning into the asset that decides who wins. To see why, it helps to start at the beginning.
A brief history of software
The first programs were not products at all. In the 1940s and 1950s, software was a set of instructions wired or punched into a specific machine to perform a specific calculation: artillery tables, census tallies, payroll. The hardware was the expensive, glamorous part. Code was an afterthought, often given away with the machine.
That changed in the 1960s and 1970s. IBM's decision in 1969 to price software separately from hardware helped create a software industry. High-level languages like FORTRAN, COBOL and C let programmers describe intent rather than wiring, and the relational database, proposed by Edgar Codd in 1970, gave businesses a disciplined way to store and query their records. From early on, the most valuable software was the software that managed data.
The personal computer of the late 1970s and 1980s put software in front of ordinary people. VisiCalc, the first spreadsheet, was the reason many businesses bought an Apple II. Word processors and desktop publishing followed. Software became something you bought in a box, installed, and owned.
The internet then dissolved the box. Through the 1990s and 2000s, software moved to the browser and then to the cloud. Salesforce made "no software" its slogan in 1999, and software-as-a-service turned programs into subscriptions. The smartphone, from 2007 on, split software into millions of small apps, each a focused window onto a particular service. By the 2010s, "software is eating the world" had become the industry's motto, and almost every company had become, in part, a software company.
The interface era: when UX became the product
As software spread to non-specialists, the interface became the battleground. Xerox PARC's graphical interface, popularized by the Macintosh in 1984, replaced memorized commands with windows, icons and a mouse. It showed that the same capability, presented better, could reach orders of magnitude more people.
By the 2010s, user experience had become a discipline of its own. Companies hired design teams, ran A/B tests, and built design systems. In crowded markets, products with nearly identical features competed on onboarding flows, visual polish, and how few taps it took to finish a task. For many products, UX had become the product itself.
Yet even then, look closely at what most of those interfaces were doing. A banking app shows balances and transactions. A CRM shows contacts and deals. A ride-hailing app shows cars on a map. Underneath the polish, nearly every screen was a carefully designed view of records in a database, plus a few buttons to change them. The industry rarely described itself this way, but the pattern was already there.
The AI shift: when logic gets cheap, data becomes the moat
Large language models change the economics of software at its root. Writing code, once the bottleneck of every project, is becoming fast and inexpensive. A competent model can scaffold an app, write the tests, and generate a dashboard in minutes. When something becomes cheap to produce, it stops being a durable advantage.
What cannot be generated on demand is the data. A model can write a perfect inventory screen, but it cannot invent a retailer's actual stock levels, ten years of customer history, or the quiet signal in how users really behave. Proprietary, well-structured, trustworthy data is now the thing competitors cannot copy by prompting.
Data also matters more because AI consumes it. Models are trained on data, grounded in it through retrieval, and evaluated against it. An AI feature is only as good as the context it is given. A company with clean, connected, permissioned data can build useful AI in weeks; a company with scattered, inconsistent data cannot, no matter how strong its model. The quality of the data layer increasingly sets the ceiling on the quality of the whole product.
UX reimagined: interfaces as views onto data and intent
If data is the substance, the interface becomes its presentation, and that presentation no longer has to be fixed. Traditional software shipped the same screens to everyone, designed months in advance. AI makes it possible to generate the view that fits the question: a chart when you ask about a trend, a table when you need to compare, a short summary when you are in a hurry, a drafted email when the next step is obvious.
This shifts the designer's job from drawing screens to shaping systems. The questions become: What data does the user need to see to trust this answer? How do we show where a number came from? When should the system act on its own, and when should it ask? How do we make uncertainty visible without overwhelming people? Good AI UX depends more on provenance, confidence, and control than on pixel layouts.
Conversation is part of this, but only part. Chat is a powerful way to express intent, yet it is a poor way to scan a thousand rows or compare five options side by side. The interfaces that win will likely blend the two: natural language to ask, and generated, purpose-built visual views to answer. In both cases, the interface is a lens on data, and its quality is measured by how clearly it lets people see and act.
What it means for the industry
The first consequence is pressure on thin software. Products whose main value was a nicer interface over someone else's data, or a workflow that a model can now perform directly, will find their margins squeezed. If a user can ask an assistant to pull the numbers and draft the report, a standalone reporting tool has to offer something more.
The second consequence is that systems of record grow more valuable. The companies that own trusted, structured data about customers, transactions, operations or the physical world sit at the foundation that every AI layer depends on. Expect more competition over who controls that data, more emphasis on interoperability and APIs, and sharper debates about privacy, consent and ownership.
The third consequence is that trust becomes a feature. As AI generates more of what people see, users will ask how they can know an answer is right. Products that show their sources, keep data fresh, respect permissions and explain their reasoning will earn adoption that slicker but opaque competitors will not. Data governance, once a back-office concern, becomes part of the product experience.
Finally, business models may shift from selling seats to selling outcomes. When software does the work rather than merely hosting it, customers will increasingly pay for results delivered from their data, rather than for access to screens.
What it means for software engineers
For engineers, the change raises the level of abstraction, much like the move from assembly to high-level languages. Typing out boilerplate CRUD screens, form validation and glue code is exactly the work AI handles well. The time it frees moves to the parts that are harder to automate.
The first of those is data. Engineers who understand data modeling, pipelines, quality, lineage and access control will be in demand, because they build the foundation every AI feature stands on. Knowing how to design a schema that stays meaningful for ten years is worth more than knowing a framework that changes every two.
The second is systems thinking and judgment. Someone still has to decide what should be built, how components fit together, where AI is reliable and where it needs guardrails, and how to evaluate whether it is working. Writing evaluations, reviewing generated code, and reasoning about failure modes become core skills rather than side tasks.
The third is product sense. As the cost of building falls, the scarce skill is knowing what is worth building and how it should feel to use. Engineers who can talk to users, understand their data and translate both into clear experiences will bridge roles that used to be separate: developer, data engineer and designer.
The practical advice follows from this. Learn the data layer deeply. Treat AI tools as collaborators and get fluent with them. Practice specifying intent precisely, because a clear spec is now directly executable. And keep the fundamentals sharp, because reviewing machine-written code requires understanding it better than the machine does.
Conclusion
Software began as instructions for machines, became products for people, and then became the interfaces through which nearly every business operates. AI is now compressing the cost of the code and the screens, revealing what was underneath all along: data, and the work of presenting it so humans can understand and decide.
Software and UX remain important, with a clearer sense of their purpose. The best products of the coming decade will be those that hold the most trustworthy data and present it with the most clarity, adapting each view to the person and the moment. For the industry, the moat moves to data and trust. For engineers, the craft moves up a level, from writing every line to designing the systems, the data and the experiences that make AI genuinely useful.