The Unwritten Software

Three corners of the market, three versions of the same question. Public-market investors ask whether the software sell-off has further to run. Private-market buyers debate whether any software business can still be bought with confidence. Software CEOs ask whether the platforms they spent years building are still the asset they were. Underneath all three: Will AI replace software?

No it won’t, and the software bill is the small number. The people working above the software cost roughly nine times as much, and most of that work stayed manual for one reason: automating it cost more than the people did. It no longer does, and that puts the larger number within reach for the first time. The shortest route into that work belongs to the incumbent vendors whose systems carry it, in regulated industries above all. Neither market has started to price that route.

Start with the pricing, because both markets are getting the same thing wrong in opposite directions. The public markets have overreacted – not in direction but in breadth: a uniform de-rating of a category whose real exposure sits in one band of the stack. The private markets have simply gone quiet – a quieter mispricing, but a mispricing all the same. Both are reacting to the same headline – agents will eat software – and the headline reads as extinction when the mechanism says repricing. Software is not going away; it is about to multiply. And the misread costs twice: it overstates an exposure that is real but narrow, and it misses the far larger cost pool opening directly above it.

I argued in the previous piece that software is the chassis and GenAI the engine – the chassis survived the car; the horse, the muscle in the middle, did not. That was about where value sits inside a business. This piece is about the chassis market itself – what happens to the industry, the vendors and the multiples when intelligence is automated and code is nearly free. Let me explain.

The deterministic floor

Begin with what does not change. No one will board a plane flown by a generative model – and the same holds for robotic surgery, industrial machinery, and, hardware or not, anything mission-critical. Wherever the input can be captured in a structured way and the output must be identical every time – or wrong so rarely that the error rate rounds to zero – the logic must be deterministic code: reproducible, testable, evidenced. That floor runs through the physical world and just as firmly through every enterprise system: calculations, state, policy enforcement, approvals, audit. Regulators and acquirers will keep asking what the system state was at the moment of decision – deterministic systems answer natively; anything probabilistic must be wrapped in guardrails, logging, and replay before it can answer at all.

So the deterministic core of the economy is not up for debate. Everything above the floor is – and that is where the market is misreading the mechanism.

Unwritten software

Here is the number that changes the analysis. For well-specified, self-contained builds – exactly the category that matters here – producing software is now roughly 10-30x faster and cheaper than three years ago, at equal or better quality. The multiple varies by context; the direction does not. Writing and shipping software has stopped being the constraint.

Now follow that number to its structural conclusion. Most of what we call the “human layer” above enterprise systems was never intelligence. It was unwritten software: work that passes the spec-writability test – the rule could have been written down before the case arrived – but was uneconomic to automate at pre-GenAI build costs. The boundary between what got automated and what stayed manual was never a capability line. It was an economics line – build cost versus loaded FTE cost times volume. GenAI has collapsed the build cost, and the work is reclassifying – in favour of whoever already owns the system it sits on top of.

GenAI did not invent new automation demand. It repriced a backlog that has existed for decades.

Every operating business carries the fossil record of that backlog: the spreadsheet estate, the macros, the end-user computing nobody dares touch, the process that exists only as “Sarah handles that”. Demand that never cleared the investment hurdle while software was written by expensive humans clears now – and much of it clears with deterministic code, not with agents.

One objection is worth taking head-on, because it is half right: coding was never the expensive part – requirements, edge-case discovery, and maintenance were. True, and it does not rescue the old boundary, because GenAI compresses those too: it interviews the process owner, drafts the spec from observed behaviour, generates the tests, regenerates the code when the rules change. And where the spec genuinely cannot be extracted in advance, you have found the territory where agents belong.

Two lines, not one

The public debate stages this as software versus AI. Wrong partition. There are two lines to draw, and they answer different questions.

The first separates deterministic automation from agentic automation. Both automate human work; spec-writability draws the line between them: where the rule can be written before the case arrives, the work belongs to code; where it cannot, and only there, agentic automation is justified. Accuracy, cost, and speed are not the line – they are why it holds. An agent that reasons through ten thousand records row by row pays for every row; an agent that writes a fifty-line script pays once and executes in milliseconds, with exact arithmetic and an inspectable artefact for the audit trail. Inference prices can fall by another order of magnitude and the line moves; it does not disappear. On writable work, the agent never justifies itself against working code on any of the three.

What remains on the agentic side is the residue: interpretation of unstructured input, synthesis, judgement, the edge case no rule anticipated. There, agentic automation transforms human work in ways deterministic software never could.

But the residue shrinks. Run agents at that frontier, watch for recurring patterns, and promote them into deterministic code – recurrence repays the build; the one-off stays with the agent. The agent does the work while harvesting the spec; agentic is a frontier, not a destination.

Agents already draw this line themselves: give a frontier model a bulk data task and it does not reason through the rows – it writes a script. We see it in coding tools and in Skills, where the model writes its own deterministic automation as part of how it works, and it scales to the organisation: GenAI as the orchestration layer, executing through deterministic code. Agents reason about what to compute; code does the computing.

Put the three layers together – a deterministic floor, a reclassifying middle, a thin agentic edge at the novelty frontier – and the equilibrium is the opposite of the apocalypse: GenAI’s biggest effect on the software estate is more deterministic code, not less.

The second line separates agentic work from human work – and capability is not what sets it; verifiability and accountability are. Agents are strongest where output can be verified more cheaply than produced: the code compiles, the extraction checks against source, the numbers reconcile. Where verification demands the same expertise as generation – a novel strategy, a judgement with no ground truth – the human check is the work, and autonomy buys nothing. And some things do not transfer at any level of model quality: bearing consequences, committing the firm, setting objectives, being the counterparty someone chooses to trust. Regulation, properly read, requires accountable oversight, not manual completion – the human role migrates from doing the work to owning it. The capability line will keep moving towards agents. The accountability line will not. Agents can do the work; they cannot own it.

The supply shock

Now put the 10-30x number back into the software market. If the build cost of a stack falls by an order of magnitude, the supply of good software multiplies – easier, faster, cheaper, better. Demand behaves differently: businesses will run far more software than today – the backlog argument says so – but not at today’s per-unit prices. In the existing market the shock destroys price, not quantity; in some segments it pushes the marginal price of software towards zero, and the market as currently constructed stops making sense. The new volume lands above the existing market, in the reclassifying human layer. Which leaves the vendor’s question – how does a software vendor make money when its artefact can be reproduced at, call it, a twentieth of the cost? The answer sits with the incumbent’s option, below.

The shock also lands unevenly, and two frictions decide where. Producing software is one thing; implementing it is another – migration, integration, change management, operational risk, inside an ecosystem that is itself evolving at the same pace, which multiplies the moving parts. From a certain size of business, replacing the stack is painful however cheap the replacement was to build; the switching cost is the rewiring, not the licence fee. And the deeper friction: why? A rewritten stack that merely reproduces the current one at a lower price does not cover the pain. The rational reason to touch the stack is not cheaper software. It is the layer above – where the real market sits, and the incumbents already hold the shortest route into it.

The nine pounds above the pound

Here is the arithmetic the end-of-software debate never runs. For every pound a business spends on software, it spends roughly eight or nine on the people doing the work on top of that software. The ratio moves by industry – one to five in some, one to twelve in others; one to nine will do. GenAI does not target the pound. It targets the nine – and that is the growth opportunity for whoever already owns the pound.

Run the case. Take the nine pounds of human work above the software. Automate two-thirds of the nine – the destination the capability curve points to, not a day-one assumption. Charge 15% of the savings – the genuinely conservative input: a modest take on delivered outcomes, from capacity that works around the clock with no hiring ramp, no attrition, no ceiling. That is 0.9 pounds of new revenue – roughly the size of the entire software market it sits on. The cautious version – one-third automated, same take – is still close to half.

One honest haircut: no single vendor addresses all nine pounds. The claim is on the labour adjacent to its own workflow – for a system-of-record vendor, call it two or three of the nine – and even that slice is a pool larger than the product it sits on.

The point is the shape, not the precision: the prize is the nine pounds, not the one underneath – which makes “will agents eat software” the least interesting question in the debate.

The incumbent’s option

Who is best positioned to capture the nine pounds? In more cases than the market currently prices – particularly in regulated industries – the incumbent software vendors.

Not because the code is defensible; because everything around it is. The incumbent is already through compliance and procurement – a gate that costs a GenAI-native challenger quarters, sometimes years, inside a bank or an insurer. Already embedded in the processes, already holding the integrations, already seeing the data flow through its product – so the customer acquisition cost on the upsell rounds to zero. An external challenger arrives with a frontier model and no context, and in most cases without the data to be genuinely useful from day one. The incumbent that knows how to use the data it already touches – at segment level, at operating level, even customer by customer – can ship bespoke, production-grade automation that moves the business needle almost immediately, cross-sold on top of the software the customer already runs, automating the human work around it. That position is hard to replicate at any build speed, because the ingredients are not built; they are accumulated.

Three qualifications keep this honest. The first is the base rate: incumbents have a miserable record with options like this – the on-prem generation mostly watched the cloud transition happen to it. What is different is the shape of the exercise: no re-platforming, no new distribution, an additive product shipped into an existing relationship – the binding variable is not capability but whether management moves.

The second is the real adversary: not the context-free startup but the horizontal incumbent – the productivity-suite owner and the model labs, also through procurement, already sitting in the email, the documents, and the generic workflow. What they do not hold is the system of record, the domain spec, or the regulated audit position. The fight is horizontal reach against vertical depth – and in regulated verticals, depth wins.

The third is scope: the option attaches to vendors whose position is state, authoritative data, and compliance standing – not to those embedded in the human layer itself. A per-seat workflow tool’s distribution evaporates with the human seats it was sold to.

For investors, this restates the valuation question. Pricing a software vendor today means pricing two things: the current book – part of which may sit in the exposed band, and should be discounted accordingly – and an option, exercisable by this vendor and largely not by outsiders, to convert distribution, data, integrations, and compliance position into the automation layer above its own product. Almost no software multiple today makes that option explicit in either direction. And the option expires – not because a stranger can replicate the ingredients, but because the customer can donate them: to its own in-house team armed with the same tools, or to a GenAI-native outsourcer handed the context the vendor assumed was exclusive. Underwriting software in 2026 is underwriting management’s intent and ability to exercise the option before it lapses.

A nuance on data, because “data moat” has become a phrase people say instead of a thing they can define. A data moat has exactly one practical manifestation: the ability to train a digital expert – the proprietary data, context, and collective knowledge of the business codified into a specialist that can substitute for the experts it learned from and be deployed everywhere at once. Expertise democratised without recruiting; capacity scaled without headcount. Everything else attributed to the data moat – propensity, segment-of-one personalisation, sharper risk, better cross-sell – comes cheap now that GenAI has made every operator a passable data scientist. Each is a derivative of the same asset. Two disciplines follow: the expert must be continuously maintained – models drift, environments change, edge cases accumulate – and a data moat no one has trained anything on is storage, not strategy.

What survives, and why

Draw the stack as a spectrum: the racks at one end, the human at the other. Every software product sits somewhere between, and exposure is proximity – the closer to the racks, the safer; the closer to the human (the more of its surface area is interfaces for people), the more vulnerable. Proximity to humans is proximity to the work GenAI absorbs.

The sort applies industry by industry; financial services makes the worked example, in three buckets.

The substrate – core banking, payments rails, policy administration – is where replacement cost falls least, because the moat sits in state, certification, and migration risk rather than in the code, and cheap code generation writes challengers all day without touching the cost of cutover.

The exposed middle – workflow tools, dashboards, UI wrappers, per-seat productivity suites – is squeezed from both directions at once: absorbed downward into generated code and upward into agents, because its whole value proposition was making the human layer more efficient, and the human layer is what is shrinking. Per-seat pricing on a shrinking human layer is a countdown timer.

And the ops-adjacent layer – KYC and AML, loan servicing, fund administration, reconciliation – is the growth bucket: external software spend is a single-digit share of a financial institution’s operating cost; the human ops layer is much of the rest. As unwritten software gets written, the addressable pool shifts from the IT budget to the cost base – and the winners will reprice from seats to outcomes, per case resolved, per loan serviced, before their customers do the arithmetic for them. The middle gets no such prize.

Underneath the sort sits the general principle: the function surviving does not mean the vendor survives. Deterministic software persists as a category; individual vendors persist only on the accumulated assets the option is built on – the authoritative data, spec, state, compliance standing, and operational embedding. Those assets used to buy the luxury of shipping slowly. Not any more. Velocity has stopped being an excuse and become the whole game.

There is a confession buried in the seats-to-outcomes repricing. Per-seat pricing was never just a revenue model; it was the industry’s way of not answering the impact question. For decades, vendors and customers alike never bothered to articulate – let alone measure – what the software actually did to the economics of the work. Run a process discovery in almost any operating business today and try to obtain the baseline: the unit KPIs, the major steps, where the time goes, what the new system is supposed to move and by how much. It mostly does not exist. The seat let everyone price access instead of proving impact; outcome pricing ends the truce, because per case resolved needs a baseline cost per case. Whoever constructs that baseline first holds the pricing power – and the vendor, already sitting in the data flow, with GenAI to do the measurement the industry skipped, is best placed to construct it. The industry is not just changing how it charges. It is being forced, forty years late, to measure what it sells.

The right question

For the public-market investor: the sell-off prices the category uniformly when the mechanism concentrates the damage in the exposed middle. The substrate holds; the deterministic estate grows. Selling the category to escape the middle is selling the chassis because the horse is in trouble.

For anyone underwriting software today: the asset class is still underwritable, and the underwrite has changed – price the book against the spectrum, then price the option. The option is observable in a data room, not a matter of faith: an automation product in the price list with attach rates; revenue already priced per outcome rather than per seat; a digital expert in production; a named owner. Where none of that exists, the option is decaying, whatever the AI slide says – and that is the diligence question worth asking of every software asset, owned or about to be bought.

And for the software CEOs who built these platforms: the platform is still the asset. It is the distribution for the real product. The decade spent accumulating data, compliance approvals, and integrations was the customer acquisition cost of the automation business – already paid, and depreciating from the day it goes unused.

“Will AI replace software?” was never the right question. Software is not what is scarce. When code is free, the scarce assets are the spec, the data, the evidence, and the accountability – and those assets sit, today, inside the software businesses already established in the market. The deterministic floor holds; the unwritable residue shrinks; the nine pounds above the pound are in play.

The decades-old backlog of unwritten software is finally getting written – by whoever holds the scarce assets and moves before the option expires. That is who gets paid, and it is being decided now.