The Death of Software Economics

The old software bargain was simple.

Build once.

Sell forever.

The first copy was expensive. The second copy was almost free. The thousandth copy was pure magic. That was the economic engine underneath Microsoft, Oracle, Adobe, Salesforce, Atlassian, ServiceNow, Shopify, and the entire SaaS mythology.

Software was not just a product category. It was a margin structure.

High fixed cost. Low marginal cost. Expanding distribution. Recurring revenue. Operating leverage. Venture capital loved it because once product-market fit appeared, the machine could scale in a way normal businesses could not.

That world is not disappearing overnight.

But its deepest assumptions are now under attack.

Generative AI does not kill software. That is too simple. Too childish. Too dramatic in the wrong way.

AI kills the economic innocence of software.

It weakens the old belief that code is scarce. It introduces variable inference cost where marginal cost used to be almost zero. It compresses feature advantage. It makes imitation faster. It pushes value away from the artifact and toward compute, data, workflow, distribution, trust, regulation, and infrastructure ownership.

The software company of the last twenty years sold access to logic.

The AI software company increasingly rents cognition from an upstream machine.

That is not a product change.

That is a change in political economy.

The Old Software Miracle

Classical software economics was built around the economics of information goods.

Hal Varian’s old framework still matters here: information goods are expensive to create but cheap to reproduce. Competitive markets tend to push prices toward marginal cost, and when marginal cost is close to zero, firms must rely on differentiation, bundling, switching costs, versioning, brand, network effects, and distribution to recover the fixed cost of creation.

That is exactly what software became.

You hired engineers. You built the product. You paid for cloud hosting, support, security, sales, and implementation. But the core product could be sold repeatedly without rebuilding it for every customer.

This created the golden triangle of software capitalism:

• High gross margins.
• Recurring subscription revenue.
• Strong operating leverage after scale.

Traditional SaaS companies could often target gross margins of 70% to 85%. The great ones could go higher. This was why investors treated software differently from services, manufacturing, logistics, consulting, or retail.

Software looked like a machine that escaped the physical world.

No inventory.

No factory floor.

No shipping container.

No human delivery cost per unit.

The myth was not completely false. Software really did have unusual economics. But the myth hid a weakness: the value of software was never only in the code. It was in the position the code occupied inside a workflow.

That distinction matters now.

Because AI attacks code scarcity first.

The First Crack: Code Is Becoming Less Scarce

AI makes software easier to produce.

Not perfectly. Not magically. Not without bugs. But easier.

Developers can generate scaffolding, write tests, create documentation, debug errors, explore unfamiliar APIs, migrate syntax, and produce working prototypes faster than before. Non-technical people can now assemble applications, automations, internal tools, landing pages, dashboards, workflows, agents, and scripts with less dependence on formal engineering teams.

This does not mean everyone becomes a great software architect.

It means the lower layers of software production are being commoditised.

The old barrier to entry was not only insight. It was execution. You needed people who could translate business intent into working code. AI does not remove that need, but it lowers the price of translation.

The predictable result is supply expansion.

More software will be built.

More internal tools will exist.

More startups will launch.

More features will be copied.

More workflows will be automated.

More “products” will appear that would previously have been too expensive to justify.

This is good for builders. It is brutal for weak software businesses.

If your moat was “we have a feature,” you do not have a moat.

If your moat was “our engineers built this complicated workflow,” you may still have something, but less than before.

If your moat was “customers trust us with regulated data, we are embedded in their operating model, we own distribution, and replacement would be painful,” then AI may strengthen you.

This is the first uncomfortable truth.

AI does not destroy all moats.

It destroys lazy moats.

The Second Crack: The Marginal Cost Is No Longer Zero

The second crack is more dangerous because it attacks the sacred heart of software economics.

Traditional software had near-zero marginal reproduction cost.

AI software often does not.

Every serious AI product can carry variable costs: tokens, inference, retrieval, embeddings, vector search, web search, tool calls, agent runtime, sandbox execution, memory, monitoring, evaluation, human review, and compliance overhead.

The product is no longer just software.

It is software plus rented intelligence.

OpenAI, Anthropic, and Google price model usage through token-based pricing. Salesforce prices Agentforce through conversation or action-based consumption. Cloud platforms price compute, storage, orchestration, and managed AI services. The market itself is telling us what the new unit of software economics is becoming.

Not the seat.

The task.

The action.

The conversation.

The workflow.

The decision.

This matters because the software company is no longer always selling a static artifact. It is selling an active cognitive process.

In the old world, serving one more user was often cheap.

In the new world, serving one more user may mean running more inference.

If the user asks more questions, the vendor pays more.

If the agent performs more actions, the vendor pays more.

If the workflow needs higher accuracy, the vendor may need stronger models, more retrieval, more validation, or human escalation.

Suddenly, usage is not only a revenue driver.

Usage is a cost driver.

That changes everything.

The Third Crack: Software Becomes More Like Cloud Infrastructure

AI pulls software back into the physical world.

For years, software people pretended the physical layer had disappeared. It had not. It was merely abstracted away by cloud providers.

AI makes that abstraction expensive.

Behind every agent is inference.

Behind inference is compute.

Behind compute is GPUs.

Behind GPUs are data centres.

Behind data centres are electricity, water, land, transmission lines, chips, export controls, capital markets, and industrial policy.

This is why the old “software eats the world” line now needs a correction.

Software ate the world when software could scale cheaply across the world.

AI software eats the world by consuming the world.

It consumes compute.

It consumes energy.

It consumes capital.

It consumes data.

It consumes institutional trust.

The new software economy is not weightless. It is industrial.

This is why Microsoft’s AI capital expenditure matters. This is why NVIDIA matters. This is why sovereign AI matters. This is why data centres suddenly look less like boring infrastructure and more like the factories of cognition.

The application layer may look magical.

The balance sheet underneath is not magic.

Five Mental Models Experts Share

Despite the noise, serious people in this field tend to share five mental models.

They disagree on timing, magnitude, winners, labour impact, and policy. But the deeper models are surprisingly consistent.

1. Essential Complexity Survives

Fred Brooks was right.

Software has accidental complexity and essential complexity.

Accidental complexity is the pain created by tools, syntax, boilerplate, configuration, setup, dependency management, and implementation friction. AI is very good at attacking this layer.

Essential complexity is different. It comes from the problem itself: what should the system do, who should it serve, how should competing requirements be resolved, what happens when things fail, what trade-offs are acceptable, what behaviour is legally safe, what data can be trusted, and how the system fits into an institution.

AI can help with essential complexity.

It does not abolish it.

This is why software does not become trivial just because code generation gets better. The hard part moves from typing code to specifying intent, validating behaviour, managing exceptions, integrating systems, governing risk, and operating the thing in the real world.

AI lowers the cost of writing code.

It raises the premium on knowing what should be built.

2. AI Software Is a Metered Service, Not a Pure Information Good

The old software product was closer to an information good.

The new AI product is closer to a metered service.

Every prompt has a cost. Every output has a cost. Every agentic action may have a cost. Every grounded query may have a cost. Every long-context workflow may have a cost. Every high-reliability process may require retries, evaluations, model routing, caching, monitoring, and fallback logic.

This turns product design into economic engineering.

Prompt length becomes cost structure.

Context windows become margin pressure.

Model choice becomes pricing strategy.

Latency becomes customer experience and infrastructure cost.

Caching becomes gross margin defence.

Routing becomes financial control.

The best AI companies will not only build better products. They will build better economic machines.

3. Scarcity Does Not Disappear. It Relocates.

This is the central law of the AI economy.

When intelligence gets cheaper, the scarce asset moves somewhere else.

It moves to compute.

It moves to energy.

It moves to proprietary data.

It moves to distribution.

It moves to trust.

It moves to workflow ownership.

It moves to regulatory permission.

It moves to institutional adoption capacity.

People keep saying AI democratises software. That is partly true at the production layer. But democratisation at one layer can create concentration at another.

If everyone can build an app, the app itself becomes less valuable.

If everyone can generate code, code becomes less scarce.

If everyone can produce content, attention becomes more scarce.

If everyone can access models, differentiated context becomes more scarce.

If everyone needs inference, compute owners become more powerful.

The economy does not become flat.

The rent moves.

4. AI Is a General-Purpose Technology, But Only Through Complements

AI is not valuable in isolation.

It becomes valuable when paired with workflows, data, incentives, training, governance, integration, and organisational redesign.

This is why the productivity evidence is uneven.

Some workers become dramatically faster. Some become slightly faster. Some become worse because they trust the model in the wrong places. Some tasks improve. Some degrade. Some firms capture value. Others buy tools and create noise.

The mistake is thinking AI adoption equals AI transformation.

It does not.

Buying Copilot is not transformation.

Adding a chatbot is not transformation.

Connecting an agent to a broken process is not transformation.

Real value appears when the workflow itself is redesigned around a different cost of cognition.

This is why second-order management matters more than first-order tooling.

5. Abundance Makes Attention and Trust More Valuable

When supply explodes, selection becomes the bottleneck.

This is the attention economy returning with violence.

If every company can publish content, content is not scarce.

If every startup can ship features, features are not scarce.

If every employee can generate reports, reports are not scarce.

If every vendor claims to have AI agents, AI agents are not scarce.

What becomes scarce?

Belief.

Trust.

Distribution.

Default position.

Customer attention.

Regulatory confidence.

Proof that the thing works in production.

This is why brand and distribution become stronger, not weaker, in the AI era. Abundance does not destroy gatekeepers. It often creates demand for stronger gatekeepers.

Five Places Experts Fundamentally Disagree

The shared models are real.

But the disagreements are also real.

And they matter because the wrong answer leads to the wrong company strategy, the wrong investment thesis, and the wrong policy response.

1. Are AI Margins Structurally Worse, or Temporarily Worse?

The bearish view is simple: AI-native software has worse margins because every unit of usage carries inference cost. Intelligence is not free. It is rented. The vendor either absorbs that cost or passes it to the customer. Either way, the old SaaS margin model is weakened.

The strongest bearish argument is that this is not theoretical. The pricing pages already show it. Token costs, search costs, agent costs, and runtime costs are visible. Large cloud providers are spending heavily on AI infrastructure. Even the strongest companies face pressure from the capital intensity of AI.

The bullish view says this is transitional. Inference costs will fall. Smaller models will improve. Caching will get better. Routing will become more efficient. Hardware will improve. Competition will push model prices down. AI products may have lower gross margin percentages but much larger revenue pools because they replace labour, services, and entire workflows.

The strongest bullish argument is that margin percentage is not the only thing that matters. Gross profit dollars matter. A product with 60% gross margin replacing a labour process may still be a monster business.

The truth is likely category-specific.

Cheap AI wrappers will get crushed.

Deep workflow systems may survive.

Infrastructure owners may win either way.

2. Are Software Moats Eroding, or Moving?

One side says moats are eroding.

If AI makes building easier, competitors can copy features faster. Product cycles compress. Design patterns spread. Agents generate code. Open-source models improve. The cost of imitation falls. Therefore, software defensibility weakens.

This argument is powerful for shallow products.

It is especially powerful for horizontal tools, lightweight SaaS, internal dashboards, content products, basic analytics, and undifferentiated automation.

The other side says moats are not dying. They are moving.

Code was rarely the deepest moat anyway. The real moats were customer ownership, distribution, data, trust, switching costs, compliance, ecosystem integration, procurement position, and workflow depth.

AI may actually strengthen these moats because customers will trust fewer vendors with more autonomous systems. If software is making decisions, touching data, taking actions, and representing the company, trust becomes more important.

This is the better answer.

Moats are not disappearing.

Weak moats are disappearing.

3. Does AI Augment Labour or Replace It?

The augmentation camp points to evidence from customer support, writing, consulting, and software development. AI helps people finish work faster. It often helps lower-skilled or less experienced workers more. It can reduce friction, improve output, and make teams more productive.

The replacement camp points to online labour markets, freelance work, entry-level jobs, structured cognitive tasks, and software-adjacent work. If a task is clearly defined, digitally delivered, and easy to evaluate, AI can reduce demand for human labour.

Both sides are right.

The question is not “augmentation or replacement?”

The question is “which task, inside which workflow, under which cost structure, with what level of risk tolerance?”

AI augments where human judgement, accountability, trust, and context remain valuable.

AI replaces where the task is routine, modular, measurable, and politically easy to automate.

The deeper danger is not only job loss.

It is apprenticeship loss.

If AI eats junior work, where do senior people come from later?

4. Do Open Models Democratise the Stack, or Do They Entrench Infrastructure Power?

The open-source optimists argue that model capability is diffusing. Open-weight models are getting better. Fine-tuning is cheaper. Inference costs are falling. Developers can build without depending entirely on frontier closed models.

This is real.

The pessimists argue that frontier AI is still brutally capital-intensive. Training the strongest models requires huge compute clusters, energy, chips, talent, data, and capital. Even if open models improve, the upstream infrastructure remains concentrated.

This is also real.

Open models democratise experimentation.

They do not automatically democratise industrial-scale AI.

A startup may use an open model.

But it still needs compute.

It still needs distribution.

It still needs data.

It still needs customers.

It still needs trust.

Open weights reduce one dependency. They do not eliminate the system of dependencies.

5. Will Demand Expansion Offset Software Commoditisation?

The optimistic view is a software version of Jevons paradox.

When something gets cheaper, we use more of it.

If software becomes cheaper to build, more software will be built. Internal tools that never made economic sense will suddenly make sense. Small markets will become viable. Personalised software will emerge. Firms will automate backlogs that were previously ignored.

The pessimistic view says attention, budgets, and trust are not infinitely elastic.

Yes, more software will be created.

But not all of it will capture value.

The world may drown in software nobody wants, nobody trusts, and nobody has time to evaluate.

This is the brutal possibility:

More software.

Fewer software profits.

More builders.

Fewer durable companies.

More automation.

Less pricing power.

More output.

More concentration.

The Second-Order Economics

The first-order story is easy.

AI makes software cheaper to build.

The second-order story is where things get interesting.

If software becomes cheaper to build, the market does not simply produce more software. It reprices software.

Buyers stop paying premium prices for things that feel easy to replicate. They become less impressed by feature lists. They care more about proof, trust, reliability, integration, security, and measurable outcomes.

This changes sales.

It changes pricing.

It changes procurement.

It changes valuation.

It changes what counts as a product.

A dashboard is not a product anymore.

A chatbot is not a product anymore.

A workflow is closer to a product.

A controlled operating system for a business function is closer to a product.

A trusted decision layer embedded inside a regulated process is closer to a product.

This is why the application layer will split.

At the bottom, there will be disposable software: cheap apps, AI-generated tools, internal automations, temporary workflows, prototypes, clones, and micro-products.

At the top, there will be control-plane software: systems that govern workflows, manage risk, coordinate agents, control cost, enforce compliance, measure ROI, and sit close to executive decision-making.

The middle gets dangerous.

Generic SaaS with weak workflow depth and no proprietary context will be squeezed from both sides.

From below by AI-generated alternatives.

From above by platforms with distribution.

The Third-Order Economics

The third-order effects are larger.

Once software becomes cheaper and more abundant, the economy reorganises around the remaining bottlenecks.

The first bottleneck is compute.

Every AI workflow increases demand for inference. Even if inference costs fall, total usage can explode. That pushes value upstream to cloud providers, model providers, chip companies, energy providers, and data-centre operators.

The second bottleneck is data.

Generic intelligence becomes less valuable than situated intelligence. A model that knows the internet is useful. A system that understands your contracts, customers, workflows, policies, exceptions, historical decisions, product margins, support tickets, operational risks, and regulatory exposure is more valuable.

The third bottleneck is governance.

As AI systems move from answering questions to taking actions, organisations need permission structures. Who can the agent email? What data can it access? What decisions can it make? When does it escalate? What is logged? Who is accountable? How is risk measured? What happens when it is wrong?

The fourth bottleneck is distribution.

In an abundant market, being discovered becomes harder. Distribution becomes more valuable because customers cannot evaluate infinite tools. The default platform wins. The workflow owner wins. The trusted brand wins. The procurement-approved vendor wins.

The fifth bottleneck is institutional capacity.

Most organisations do not fail because AI is unavailable.

They fail because they cannot absorb it.

Their data is messy.

Their processes are political.

Their incentives are broken.

Their governance is immature.

Their leaders want productivity without redesign.

AI exposes organisational truth.

That is why the winners will not simply be the firms that buy the best models.

The winners will be the firms that can rewire themselves around a lower cost of cognition.

The Labour Market Problem Nobody Wants to Say Clearly

AI will not replace “jobs.”

It will replace bundles of tasks.

That sounds comforting until you understand how jobs are built.

Many junior jobs are collections of structured tasks: drafting, searching, summarising, reconciling, testing, checking, preparing, formatting, documenting, reporting, analysing, and escalating.

These tasks are exactly where AI is useful.

So the danger is not a clean apocalypse where everyone is fired tomorrow.

The danger is slower and more structural.

Hiring freezes.

Smaller junior cohorts.

More output per senior worker.

Less tolerance for training.

More demand for people who can supervise AI systems.

Less demand for people who used to learn by doing the work AI now does.

This creates a broken ladder.

The senior people become more powerful.

The juniors lose the apprenticeship path.

The firm becomes more productive in the short run and more fragile in the long run.

This is not just a labour issue.

It is a capability issue.

Economies that destroy apprenticeship eventually destroy expertise.

The New Software Stack

The old software stack looked like this:

1. Infrastructure.
2. Platform.
3. Application.
4. User.

The new AI software stack is different:

1. Energy.
2. Data centres.
3. Chips.
4. Cloud infrastructure.
5. Foundation models.
6. Model routing and orchestration.
7. Proprietary context.
8. Workflow systems.
9. Governance layer.
10. Distribution interface.
11. User or agent.

This matters because value capture follows control points.

If you control chips, you tax the model layer.

If you control cloud, you tax inference.

If you control the foundation model, you tax cognition.

If you control workflow data, you tax relevance.

If you control distribution, you tax attention.

If you control governance, you tax permission.

If you only control a feature, you are exposed.

This is the new map.

Ten Foundational Questions

The question is not whether AI changes software. That question is already dead.

The real questions are deeper.

1. What happens to software pricing when customers know the product is easier to build?
2. What happens to SaaS gross margins when every meaningful user action triggers inference cost?
3. Which software categories become disposable first?
4. Where does defensibility move when code is no longer scarce?
5. Does AI create more software businesses, or simply more software?
6. Who captures the surplus when AI tools replace labour: the application vendor, the model provider, the cloud platform, the customer, or the worker?
7. What happens to junior talent pipelines when AI absorbs entry-level cognitive work?
8. Will open models decentralise power, or will compute and distribution recentralise it?
9. How should companies measure ROI when AI output is cheap but verification is expensive?
10. What becomes the new unit of software value: seats, usage, actions, outcomes, decisions, or avoided labour?

These are not academic questions.

They are the operating questions of the next software economy.

The New Rules

The old rule was: build software.

The new rule is: control the workflow.

The old rule was: sell seats.

The new rule is: price outcomes, actions, or controlled usage.

The old rule was: code is leverage.

The new rule is: context is leverage.

The old rule was: scale creates margin.

The new rule is: scale creates cost unless engineered carefully.

The old rule was: software is capital-light.

The new rule is: AI software is connected to one of the most capital-intensive infrastructure races in history.

The old rule was: product wins.

The new rule is: product plus distribution plus trust plus data plus compute discipline wins.

Conclusion: Software Is Not Dead. Code-First Software Economics Is.

Software is not dying.

Software demand will grow.

More software will be created than ever before.

More workflows will become programmable.

More companies will depend on software.

More economic activity will pass through software systems.

But the old economics are dying.

The old belief that software automatically means high margins is dying.

The old belief that features create durable moats is dying.

The old belief that code scarcity protects software companies is dying.

The old belief that digital products escape physical constraints is dying.

The old belief that software companies are always capital-light is dying.

The next software economy will not reward people who merely build.

It will reward people who control.

Control compute.

Control context.

Control workflow.

Control trust.

Control distribution.

Control governance.

Control cost.

That is the death of software economics.

Not the death of software.

The death of the fantasy that software lives outside economics.