Who Owns the Future Stack?
Code Matters — Flagship Essay, Part III
Software used to be something you owned.
You bought a machine.
You installed programs.
You ran code locally.
You understood where things lived and how they worked.
Today, most software exists somewhere else.
In someone else’s cloud.
Behind someone else’s API.
Running on someone else’s terms.
And slowly, without noticing, developers stopped owning their tools.
The stack moved upward
Every generation of software abstracts the one below it.
Hardware became operating systems.
Operating systems became platforms.
Platforms became services.
Services became APIs.
APIs became AI.
Each step made building easier.
Each step also moved control further away from the builder.
Today, a modern product might depend on:
cloud infrastructure it cannot migrate from
models it cannot inspect
APIs it cannot replace
pricing it cannot predict
The result is convenience without sovereignty.
The new choke points
Power in software no longer comes from writing code.
It comes from controlling access.
Cloud providers control:
compute
storage
networking
deployment
AI providers control:
intelligence layers
model behavior
safety boundaries
pricing per decision
Platform owners control:
distribution
visibility
monetization
You don’t compete by building better systems anymore.
You compete by negotiating with infrastructure.
Dependency as architecture
Modern systems are built from dependencies.
Libraries depend on frameworks.
Frameworks depend on services.
Services depend on platforms.
Platforms depend on policies.
Every dependency reduces friction — and increases exposure.
When one layer changes:
pricing changes
terms change
rate limits change
behavior changes
And entire products break overnight.
This is not failure.
This is the logical outcome of centralized abstraction.
Open is not the same as free
The industry likes the language of openness.
Open APIs.
Open models.
Open ecosystems.
But openness often stops at the surface.
You may see the interface, but not:
the training data
the infrastructure
the optimization layers
the economic incentives
You can build on top of the stack.
You rarely control it.
And control is what determines the future.
The invisible lock-in
Lock-in used to be technical.
Now it is economic and cognitive.
Switching providers means:
rewriting architecture
retraining teams
rebuilding pipelines
losing accumulated knowledge
So companies don’t switch.
They adapt.
Over time, the stack stops being a tool and becomes an environment — one that defines what is possible before you even start building.
The developer’s quiet trade
We traded ownership for speed.
And it made sense.
Cloud removed hardware pain.
APIs removed complexity.
AI removes effort.
But every removed difficulty also removes understanding.
And when understanding disappears, so does leverage.
The builder becomes a tenant.
The future stack
The future of software will not be defined by who writes the best code.
It will be defined by who controls:
computation
models
data
and distribution
This is why AI feels different.
It is not just another tool layer.
It sits at the top of the stack, shaping decisions beneath it.
The higher the abstraction, the greater the power.
What this means for builders
This is not an argument against cloud or AI.
These tools made extraordinary things possible.
But builders need to recognize the trade:
Convenience concentrates power.
If you don’t understand the stack you depend on, you don’t control your product’s future.
And if enough builders lose control, innovation itself becomes permissioned.
Why Code Matters exists (Part III)
This series began with blind software.
Then the illusion of intelligence.
And now the question beneath both:
Who decides how systems behave?
Code still matters but ownership matters more.
Understanding where power lives in the stack is no longer optional.
It is the difference between building the future and renting it.
Because the future of software will not be decided by what we build.
It will be decided by where we are allowed to build it.