The End of Features

For years, software companies got to count build difficulty as strategy.

If a feature took a team of 10 engineers six months to ship, that difficulty bought you time. Competitors could copy the idea, but they still had to pay the same tax in headcount, coordination, and calendar time.

AI is stripping that protection out of the equation.

Product quality still matters. What changes is the thing many companies were calling a moat. A lot of the time it was just expensive production. When the cost of building falls fast enough, the strategic question changes. It stops being "what can we ship next?" and becomes "what do we have that someone else cannot rebuild in a quarter?"

The numbers make the shift concrete. Stripe's internal agent system — Minions — merges over a thousand agent-written pull requests per week. No human writes the code; humans review only. Spotify's background agent, Honk, has merged more than 1,500 PRs across hundreds of repositories, and roughly half of all Spotify PRs are now automated. Ramp reached 30% of all merged PRs coming from its agent within a couple months of launching. OpenAI built an entire internal product — approximately a million lines of code — with three engineers, zero manually-written code, in five months.

Those are not research demos. Those are production systems at companies processing real revenue. And the trajectory points in one direction: the cost of building features is collapsing toward the cost of describing them.

The map looks like this:

                    Easy to copy    Hard to copy
                 +---------------+---------------+
   Digital       |   Features    |   Networks    |
   (bits)        |   and code    |   and data    |
                 +---------------+---------------+
   Physical      |   Hardware    |   Atoms and   |
   (atoms)       |   specs       | relationships |
                 +---------------+---------------+

Most product teams still spend most of their time in the upper left.

Why this changed

The easiest way to misread AI is to think it mainly makes software teams more productive. It does that. The bigger change is that it makes feature production cheaper, faster, and easier to replicate.

The signs are already here:

• Frontier models can produce production-grade code inside real repositories.
• Background agents now work in isolated environments, run tests, and open pull requests without a human sitting there.
• Open-source orchestration blueprints are turning what used to require a platform team into something a motivated engineer can assemble over a weekend.

Once that happens, a feature stops looking like a strategic asset and starts looking like manufactured output. A useful one, sometimes a necessary one, but not the thing that protects the business.

Ben Thompson's Aggregation Theory helps explain the mechanism. Thompson's core insight is about what happens to value chains when a layer of the stack gets commoditized. When distribution was expensive, newspapers could charge advertisers because they controlled access to readers. When the internet made distribution free, value migrated to whoever could aggregate demand — Google, Facebook — and away from the suppliers of interchangeable content.

The same structural logic applies to software features. For decades, the "supply" side of software — the actual building — was expensive enough to function as a barrier. You needed engineers, time, and coordination. That expense meant the supply of any given feature was limited, which gave the companies that built them pricing power.

AI is doing to software features what the internet did to media content: making supply abundant. When supply gets abundant, Thompson's framework predicts that value migrates toward demand aggregation and away from supply. The companies that own user relationships, distribution, and data — the demand side — gain leverage. The companies whose value proposition is "we built this feature so you don't have to" lose it, because the cost of "building it yourself" is dropping toward zero.

This doesn't mean features become worthless. Content didn't become worthless when distribution got cheap. But content stopped being the defensible layer. It became the commodity input to someone else's aggregation model. Features are heading to the same place.

The speed of the shift matters too. Cursor's research system peaked at a thousand commits per hour running a multi-agent harness continuously for a week. OpenAI's team averaged 3.5 PRs per engineer per day — and the engineers weren't writing code, they were reviewing it. These rates mean that a startup can ship on Monday and face a functional clone by Tuesday. The calendar-time moat that used to protect complex features has been sanded down to almost nothing.

What survives

Some assets get stronger when code gets cheaper because they were never made of code in the first place.

Networks

You cannot prompt your way into a social graph. Spotify's recommendation strength is tied to hundreds of millions of listening histories. Meta's position is tied to the topology of human relationships. The product surface matters, but the compounding asset underneath it matters more.

Networks have a specific property that makes them resilient to feature commoditization: they get more valuable as more people use them, and that value is locked inside the network itself. You can clone Spotify's interface. You cannot clone the behavioral data of 600 million users making daily listening choices. The gap between "what the product looks like" and "what makes the product work" widens every day those users keep listening.

Data flywheels

Google's edge is not a single search feature. It is the loop between usage, ranking signals, and model quality. NVIDIA's position is not just CUDA as an API. It is the accumulation of libraries, workflows, and institutional habits built around it. These assets improve as they are used.

The flywheel distinction matters because data flywheels create a compounding advantage that accelerates over time. A feature, even a brilliant one, depreciates. Someone copies it or builds something better. A data flywheel does the opposite — each interaction makes the next interaction more valuable. When AI makes the feature layer cheap, the relative value of the flywheel layer increases. The gap between "we have a good product" and "we have a good product built on a decade of usage data" becomes the whole ballgame.

Relationships and embeddedness

Enterprise software survives on more than UI. Procurement history, compliance posture, workflow integration, and trust built over years all create switching costs. Microsoft is not hard to displace because its interfaces are impossible to copy. It is hard to displace because thousands of organizations have already bent themselves around it.

This is worth dwelling on because it's the moat least visible to product teams. Nobody ships "embeddedness" as a feature. It accumulates through years of integrations, training investments, compliance certifications, and organizational muscle memory. An AI agent can replicate a competitor's dashboard overnight. It cannot replicate the fact that a customer's entire procurement workflow, approval chain, and audit trail run through your system.

Physical infrastructure

Data centers, fabs, fleets, logistics networks, and the capital structures behind them do not become easy to copy because code generation improved. You can clone a dashboard. You cannot clone a fabrication plant on a weekend.

These are the assets I would bet on in a world where feature production gets cheap.

The Aggregation Theory lens

It's worth making the Thompson connection more explicit, because it clarifies which companies are in trouble and which aren't.

In Thompson's framework, pre-internet media value chains had three layers: suppliers (journalists, studios), distributors (newspapers, TV networks), and consumers. Distributors captured most of the value because they controlled access to consumers. The internet blew up distribution costs, which commoditized the distributors and shifted value to aggregators — platforms that sat between abundant supply and consumer demand.

Software is developing an analogous structure. The three layers are: builders (engineering teams), products (the software itself), and users. For decades, the building layer was expensive enough to function as a bottleneck. Products captured value because they were hard to create. AI is removing that bottleneck. Building is getting cheap. When building gets cheap, the product layer — the feature set — starts to look like content in the media analogy: abundant, interchangeable, and no longer the defensible layer.

Where does value migrate? Toward the layers that still have scarcity. User relationships. Distribution. Proprietary data. Regulatory position. Physical infrastructure. The things on the right side of the defensibility matrix.

This is why "ship features faster" is a trap. It's the equivalent of a newspaper saying "write more articles" in 2005. More supply doesn't help when supply is no longer scarce. What helps is controlling the layers that are still scarce.

Why this is uncomfortable

Most product organizations are not staffed, measured, or rewarded around those assets. They are rewarded around visible shipment.

Roadmaps make this obvious. The work that gets celebrated is new screens, integrations, automation flows, and launch announcements. The work that compounds a data advantage, deepens a customer relationship, or increases workflow embeddedness often gets treated like supporting detail.

That was always a mild problem. It becomes a strategic one when the visible work gets easier for everyone at once.

If your product strategy is mostly "we ship a better set of features than the next company," AI is attacking the part of the stack you rely on most. Faster execution helps, but it helps your competitors too. The result is not no progress. The result is faster convergence — everyone arrives at the same feature set quicker, and the window during which your feature advantage matters shrinks from years to months to weeks.

The companies most exposed are pure-feature SaaS businesses — the ones whose entire value proposition is "we built this so you don't have to." If an AI orchestration layer can build it for the customer directly, tailored to their specific workflow, the per-seat middleman loses pricing power. Not immediately. Not completely. But the pressure is structural and it only moves in one direction.

There's a flip side, though, and it's worth naming. The same force that makes features indefensible for companies makes them accessible for individuals and small teams. Purpose-built software for specific workflows becomes viable at a scale of one. The person who understands a problem deeply can now build the solution directly, without needing to convince a product team to prioritize it or a company to fund it. That democratization is real, and it matters.

Boundaries

Features are not irrelevant. Users still buy products, not abstract moats.

Taste does not disappear. Product judgment still matters. A clean workflow, a strong opinion about how work should happen, and a better interface can create real value.

Not every business needs a network effect or a fab. Some companies will survive through deep vertical specialization, regulated workflow integration, or proprietary operating data that is small in scale but rich in value.

The narrower claim is simpler: features without something compounding underneath them are weaker bets than they used to be.

I think that's right.

How to use this

If you are a founder or product leader, audit the roadmap in two passes.

First pass: what are we shipping because users need it right now?

Second pass: what are we shipping that becomes harder to replace the more it is used?

Those are different categories of work. Both matter. Only one deserves to be called strategy.

The simplest test is brutal:

• If a competitor shipped this same feature in 90 days, would our position materially change?
• If users could recreate a rough version with the same AI tooling we have, would we still have an advantage?
• If this work succeeds, what compounds?

If the answer to the last question is "nothing," you may still need to build it. Users still need the thing. But you should stop mistaking necessity for defensibility.

That is the real shift. The upper-left quadrant does not go away. It just gets demoted. Features become the price of entry. The durable part of the business has to live somewhere else.