Software Isn't Dying. It's Growing Up.
How leader's should be thinking about their software stacks. It's not all going to be just AI agents talking each other. Software continues to be the backbone of strong, sustainable organisations.
Executive Summary: Software is not dead. AI is here and real. But the replacement narrative for software or for humans isn’t.
Three years post-ChatGPT, apps 4–50 in the App Store still aren’t AI apps—they’re just apps. Our complex and messy world demands simplifications, and apps continue to provide that.
Since the first Jacquard loom in 1801, which required human operators to monitor and override, every wave of automation has introduced new abstractions of existing knowledge, which was framed as control surfaces for looms that required operators, autopilots that required pilots, and now AI will require new control surfaces.
Why? Because machines couldn’t and probably can’t be expected to be held accountable.
This automation cycle is part of a continuum. What is changing in this automation cycle? Only how this new control surface is built with AI.
What stays: Humans stay in control with new control surfaces. Call it Apps, SAAS, whatever you may.
Starting with A Provocation
I am bullish on AI. But, sceptical of the replacement narratives that border on the One-ring-to-rule-them-all, which is at best fictional.
Why? The organic world is messy and chaotic. That’s why we don’t see combustion engines surviving on their own in the world. They haven’t learned to survive efficiently.
Having spent 20 years in product and leadership roles selling servers to food and fashion, I’ve learned to distrust predictions that sound inevitable.
Early in my career, in 2008, Facebook games and apps were the rage. Then Blackberry. Fast-forward, and the metaverse was supposed to replace the internet. Crypto was supposed to replace banks. And now, AI is supposed to replace software?
It won’t. And, the reasons aren’t obvious or discussed well enough.
Three years ago, Sam Altman posted a tweet, and the world changed.
ChatGPT became the fastest-growing consumer application in history. Investors are pouring billions into AI infrastructure.
As I write this in early Feb 2026, software stocks lost over $1 trillion in market value, with the sector down 30-40% on AI disruption fears. The iShares Software ETF entered a bear market, down 27% from its 2025 peak. Yet even as investors panic about AI replacing software, Microsoft’s Azure still grew 62%, and enterprise SaaS renewal rates remain strong.
If you were to believe the market, software is dead, and users would simply talk to AI and get outcomes; no interface required, and we will all go back to a terminal or chatbox.
And yet.
Brian Chesky, CEO of Airbnb, recently made an observation that prompted me to rewrite a post I was writing, ‘Junior Software Engineering jobs are dead,’ and reassess.
He said, “If you open the App Store today and look at the top 50 applications, the first is Sora, the second is ChatGPT, the third is Gemini. Apps four through fifty? They’re the same applications that existed before AI. Not AI apps. Just apps. Instagram, WhatsApp, Uber, Spotify. Three years into the supposed revolution, the application layer hasn’t been replaced. It’s been augmented.”
Intelligence, Chesky argues, is the gold. But gold isn’t useful until you build something with it. We invented the jet engine and strapped it to a car. We still need to invent the airplane. That airplane is software.
Which was when I realised, software isn’t going anywhere.
What is software really? How do we assess its utility?
The replacement narrative goes wrong at this specific point: it misunderstands what software does.
It’s natural to assume that software is just code. Code is just implementation.
Software is the combination of three things working together:
An Interface or surface that makes computation usable by humans
A Business Logic layer that encodes business logic and outcomes
And, a Backend with Storage and infrastructure that wires it all together
Strip any of these away, and you don’t have software—you have an experiment. A sophisticated automation script: works flawlessly until it fails, and only its creator understands why.
People who predict software’s death tend to fixate on the code. If AI can generate code, they reason, then engineers become obsolete, and software disappears into pure intelligence. But this confuses the recipe for the meal.
Code was never the point. Outcomes were always the point. And outcomes require something code alone cannot provide: accountability.
I call this the doorman theory. Extending from the doorman fallacy.
Scenario #1: In any complex system—a building, an airline, a corporation—there exists a role that appears redundant until the system meets reality. The doorman doesn’t design the building’s security protocols or maintain its infrastructure. He doesn’t write the access control rules or manage the automation.
But he’s the one who recognizes the regular tenant who forgot their key. He spots the pattern when something seems off. He has the authority to override the automated system when it makes the wrong call. He accepts accountability for decisions that require human context.
Software is that doorman.
Scenario #2: When the aircraft you are flying home on is on autopilot, the flight management system can fly the route, manage thrust, and follow approach paths, but the pilot still has to monitor the instruments, cross-check the avionics, and be ready to disconnect the system if anything looks off.
The same goes for AI systems that now sit in the loop of our work: they can propose actions, execute sequences, and optimise for efficiency, but they still require a human with the authority to intervene, override, and accept responsibility. This isn’t inefficiency; it’s safety infrastructure. The captain stays in the cockpit because perfection doesn’t.
The replacement narrative assumes AI will achieve perfect reliability. But perfect reliability is not a technical milestone we’re approaching. It’s a philosophical impossibility.
Systems fail. Contexts shift. Edge cases multiply.
The question isn’t whether AI will make mistakes—it’s who takes responsibility when it does. That responsibility requires a control surface. That control surface is software.
Software is the doorman; the Accountability Infrastructure.
How does Software come into being?
There’s a deeper reason software will persist, and it has nothing to do with technology.
Humans trust the judgment of other humans.
Our entire civilisation runs on this principle.
We trust doctors not because we understand medicine, but because we trust the institutions that trained them.
We trust pilots because we trust the systems and institutions that certified them.
We trust not because we’ve read every clause, but because we trust the lawyers who drafted them.
Software is the borrowed judgment of teams of people who have standardised complex processes–Product managers, CEOs, Software Architects, etc. Like the avionics infrastructure of an airplane, we trust everyone involved has done the right thing so the plane is airworthy, not just the pilot.
Scenario: When I open a banking application, I’m not evaluating the cryptographic protocols securing my transactions. I’m trusting that someone, or many someones, already did that work. The interface presents me with choices that have been pre-validated, pre-tested, and pre-approved by people I’ll never meet. Their judgment has been encoded into the system. I borrow it every time I tap a button.
AI doesn’t eliminate this need. AI intensifies it.
AI amplifies in both directions. When sound judgment is encoded into software, AI scales it across millions of interactions—Microsoft’s Dragon Medical AI distilled 600,000 expert physician decisions into a system now used globally.
But errors scale just as fast. AI-generated code shows 20-45% more security vulnerabilities than human-written code. One in five security leaders reports production incidents from AI systems. Speed cuts both ways: expertise at scale, or mistakes at scale.
The infrastructure that defines “good” and catches “bad” becomes more critical, not less. That infrastructure is software.
AI generates. Humans encode judgment about what “good” looks like. That encoding is software.
In the movie Skyfall, Q dismissively states that everything could be technology, invoking the efficiency argument—automation is faster, cleaner, and more precise —while adding, “Sometimes we need someone to pull a trigger.” Bond’s reply is two words: “Or not.” Two words that contain the entire case for human override.
Automation works until it doesn’t. And when it doesn’t, you need someone with the authority and the interface to say no.
That authority requires a software layer as a cascade of controls. Not because AI or other humans are incapable, but because humans are accountable.
Software is one of the systems of Borrowed Judgment humanity relies on. And the increasing levels of abstraction encode this borrowed judgment over time into systems we once built, but we forget … that knowledge still does its job, embedded deep in some microservice in a data centre’s cooling infrastructure, or regulating a hospital HVAC system in a NICU.
The Automation Continuum
AI is not a revolution. It’s a pattern.
In 1801, Joseph Marie Jacquard introduced punch cards to automate silk weaving. He was inspired by Adam Smith’s 1776 ‘Wealth of Nations’ where he introduced the idea of division of labor as the main engine of productivity. The looms Jacquard built didn’t eliminate weavers. This created loom operators. Someone still had to load the cards, monitor the threads, and intervene when the pattern went wrong.
A century later, Henry Ford’s assembly lines didn’t eliminate craftsmen. This created line supervisors. The line was the machine; humans became the control layer, watching for jams, managing flow, pulling the cord when something broke.
Another century later: Autopilot didn’t eliminate pilots. The flight management computer handles 95% of cruise flights. The captain now has more cognitive bandwidth to intervene when the 5% judgment matters: weather decisions, mechanical anomalies, and the moment when the automation does something unexpected.
David Alan Grier, historian of computing, puts it bluntly: “AI is not new. It’s figuring out how to take repetitive work, systematize it, and replace humans. We’ve been doing that since the 1770s (since Adam Smith).“
Every wave follows the same sequence: identify repetitive human work, systematise it, encode rules, automate execution. And every wave produces the same outcome—not fewer humans, but humans in different positions. The position shifts from doing to overseeing. From execution to judgment. From operating the machine to deciding when the machine is wrong.
Looms required operators. Assembly lines required supervisors. Autopilots required pilots. AI requires software-defined control surfaces.
We need the doorman. The doorman doesn’t disappear. The doorman gets promoted.
This is the pattern that replacement narratives miss. They see the automation and assume the human vanishes. History shows the opposite: automation creates new interfaces, and those interfaces require human operators with authority to override.
Software is encoded judgment as a predictable, consistent machine layer, stringing together AI & humans.
What Changes, What Stays
None of this means software remains static. The transformation is real—it’s just not a replacement.
What changes is how software gets built and who builds it.
Andrej Karpathy (Stanford, Tesla, OpenAI) describes three eras:
Software 1.0, where humans wrote explicit code
Software 2.0, where neural networks learned from narrow data; and
Software 3.0, where now natural language becomes the programming interface.
Each era added a paradigm without eliminating the previous ones. We still write explicit code. We still train neural networks. Now we also prompt AI systems. The application layer absorbs all three.
The implication is profound: domain experts can now become software builders.
Excel put financial modelling in the hands of domain experts; AI is now putting application development in theirs too. Claude in Excel is doing this now. You don’t need a junior analyst for this. Simple instructions can generate functional financial models with assumptions from scratch in minutes, given the input instructions are at least decent.
A compliance officer who understands regulatory requirements can now describe those requirements in natural language and generate a working system.
A supply chain manager who understands logistics constraints can orchestrate AI agents to optimise routing.
The software engineer doesn’t disappear. The software engineer becomes the orchestrator, the reviewer, the person who ensures the generated system actually works. Call them whatever you want to – AI Engineer, Systems Engineer.
What stays is the need for interfaces, accountability, and human judgment.
Product surfaces will become more adaptive—learning from interactions, personalising experiences, and moving UI elements to maximise individual productivity. Applications will retain memories of previous interactions, enabling contextual recommendations that static systems could never provide. But these adaptive systems still require interfaces that humans can read, audit trails that humans can review, and control mechanisms that humans can operate.
The doorman remains. The doorman just gets better tools.
The Real Shift
Software isn’t dying. It’s finally growing up.
For fifty years, software meant translating human intent into machine-readable instructions. That translation was expensive, slow, and required specialists. Over the last few decades, we have increasingly made complex systems into abstractions, as the physical layer (e.g., 65nm to 3nm chips) and the software layer (Basic to React) have deepened their capabilities.
We now design systems in what looks like plain English, but those words still hard-code how the technology behaves and what it optimises for. Where you once expressed outcome rules in COBOL, C++, or Ruby on Rails, you can now do it in your own language—yet the responsibility for intent, alignment, and impact hasn’t moved; it’s just become more legible.
AI removes the translation bottleneck. But removing the translation doesn’t remove the intent. It doesn’t remove the need for outcomes. And it certainly doesn’t remove the need for accountability when those outcomes fail.
The companies that adjust, understand, and evolve to this new paradigm will thrive. They’ll treat AI as the new substrate for software—the gold from which applications are built—rather than a replacement for the building itself. They’ll invest in interfaces that make AI systems controllable, auditable, and trustworthy. They’ll recognise that the doorman isn’t a bug in the system. The doorman is the system.
The companies that don’t understand this will learn the hard way. They’ll ship autonomous systems without control surfaces and discover, expensively, that perfect reliability doesn’t exist. They’ll automate judgment without embedding accountability, leaving them unable to explain what went wrong. They’ll mistake the gold for the currency.
Intelligence is abundant. Trust is scarce. Software is how we bridge the gap.
AI will not replace software. AI will make software matter more than ever.
In summary, here are my first 5 predictions for the future of software …
I. Software is accountability infrastructure.
The doorman doesn’t understand the elevator’s logic board, but knows which lever to pull when it fails. Governance persists because perfection doesn’t.
II. Software is borrowed judgment.
Humans trust human judgment—doctors, pilots, lawyers, interface builders. AI generates; humans encode what “good” looks like.
III. Humans decide; AI advises.
The buck stops with humans. Overriding authority isn’t optional—it’s the point.
IV. Every automation wave creates new control surfaces.
Looms required operators. Autopilots required pilots. AI requires software-defined control surfaces. The pattern has been around since the first recorded automation experiments in 1810.
V. What changes is how software is built. What stays is why it exists.
Code → prompts → agent orchestration. But interfaces humans can read, control surfaces humans can operate, and accountability structures answering “who’s responsible when it fails?” remain non-negotiable.
VI. …
Part 2: The Next 5 Predictions (For the Next Essay) - A deeper dive into the systems that are changing.
What’s your take? Where does this argument break? I’d rather be challenged than comfortable.