Every major productivity revolution starts with the same fear.
If we can suddenly produce 100× more output per hour, won’t everything become cheap? Won’t margins collapse? Won’t there be too many players? Won’t the people who used to do this work become irrelevant?
We’ve asked this question before. We just don’t usually recognize it in the moment.
Agriculture went through this when mechanization and better seeds allowed one farmer to feed hundreds instead of a handful. Manufacturing went through it when assembly lines and automation made output explode. Printing went through it when movable type turned writing from a craft practiced by monks into something ordinary people could do.
Software is now entering that phase.
For most of its history, software development had a hard bottleneck: how much good code a team could write. Ideas were plentiful. Demand was plentiful. What wasn’t plentiful was the ability to turn intent into working systems. That scarcity shaped everything: company sizes, pricing, product scope, even the mythology of “10x engineers.”
That bottleneck is dissolving.
One person can now do what used to require a small team. Soon, they’ll do what used to require a department. Not because they’re smarter, but because the tools are better. The interesting question isn’t whether this will change the industry—it already is. The question is what happens to companies when the cost of producing software collapses.
History helps here.
In agriculture, productivity gains didn’t shrink the industry. They grew it. Fewer people worked the fields, but food became cheap enough to support cities, universities, science, and art. The work didn’t disappear; it moved. Farmers became logistics operators, machinery experts, supply-chain managers. The winners weren’t just the people who could grow crops—they were the ones who knew how to scale, distribute, and adapt.
Manufacturing followed the same pattern. The assembly line didn’t create fewer manufacturers; it created global ones. Mitsubishi didn’t start as a conglomerate. It became one because manufacturing excellence made it possible to expand horizontally. Once you are very good at producing things, what you produce becomes a secondary question.
Printing is the closest analogy to software.
Before the printing press, content was scarce. After it, content became abundant—but attention didn’t. The result wasn’t a world where writers stopped mattering. It was a world where distribution, trust, and taste mattered more than the mechanics of production. A long tail emerged. A few massive winners appeared. And between them, an enormous middle flourished.
Software is heading in the same direction.
When code is abundant, the differentiator is no longer “can you build this?” It’s “should this exist?” and “does this actually work in the real world?” That shifts value away from raw production and toward judgment, context, and integration.
This is where many software companies will get confused.
It’s tempting to think that if individuals can now build full products, companies must necessarily shrink. Sometimes they will. But historically, productivity revolutions don’t eliminate organizations—they change what organizations are for.
A modern manufacturing company isn’t a group of people hammering metal. It’s an orchestrator of systems: machines, suppliers, logistics, quality control, distribution, customer relationships. The same thing is happening to software companies.
As code becomes cheap, companies stop being factories and start being institutions.
They exist to decide what to build, to ensure consistency, to manage risk, to translate messy human needs into coherent systems, and to be accountable when things break. These are things individuals are bad at doing alone, even if they’re excellent at writing code.
This is especially true in enterprise software.
Every enterprise sale has always had a hidden truth: no two customers are actually the same. The “one-size-fits-all” SaaS model worked not because customers were identical, but because customization was expensive enough to suppress demand for it. Now that cost is collapsing.
In a world of abundant software, customization stops being friction and starts being expectation.
The companies that win won’t be the ones that resist this, but the ones that structure themselves around it. They’ll have a strong core product, but they’ll treat it as a foundation, not a boundary. They’ll look less like pure SaaS vendors and more like outcome-driven partners—software firms that can adapt rapidly without breaking themselves.
This doesn’t mean turning into a consulting shop. It means recognizing that when production is cheap, adaptation becomes the scarce skill.
It also changes who you hire.
You need fewer people whose job is to mechanically produce output, and more people who interface with reality: customers, workflows, constraints, regulations, adoption. In manufacturing, this meant more engineers and fewer laborers. In software, it means more product thinkers, domain experts, and customer-facing operators—and fewer people whose sole value is typing speed.
The final fear is the biggest one: that the giants will eat everything.
It’s possible that AI platform companies will resemble industrial conglomerates—horizontal, powerful, everywhere. But history suggests a split outcome. Core infrastructure consolidates. Application and domain layers fragment. Giants provide leverage; specialists provide meaning.
The printing press didn’t eliminate authors. It created them.
Software abundance won’t eliminate software companies. It will force them to answer a harder question: why do we exist, if building is no longer the hard part?
The companies that answer that well won’t just survive this transition. They’ll grow into something larger than they could have been before—not because they write more code, but because they matter more.