Making software companies out of non-software businesses
The Coming Software-Nativization of the Real Economy
For the last two decades, we treated software as a sector.
There were software companies, and then there were “real businesses” — logistics companies, manufacturers, clinics, brokers, contractors, distributors, lenders, restaurants, warehouses, staffing firms, and hundreds of other operational businesses that used software but were not themselves software-native.
That distinction is about to break.
Not because every business will become a SaaS company.
And not because every founder will suddenly learn to code.
But because one of the deepest historical constraints on firm design is being removed:
good software engineering has always been scarce, expensive, slow, and organizationally difficult to acquire.
As AI-native software studios and AI-native engineering systems rapidly increase the supply of software creation, many real-world businesses will stop merely “using software” and start being built as software-native entities from the inside out.
That is the real thesis.
And it has less to do with technology glamour than with basic economics.
Start from first principles: firms are shaped by bottlenecks
A business is not just a product or a service.
A business is a system for coordinating labor, capital, information, and decision-making under constraints.
Every industry ends up looking the way it does because of its bottlenecks.
If transport is expensive, supply chains look one way.
If capital is scarce, firms grow one way.
If distribution is scarce, brands form one way.
If skilled management is scarce, organizations centralize one way.
For the last few decades, one of the hidden bottlenecks shaping almost every company has been this:
the ability to translate operational reality into custom software systems has been scarce.
That scarcity had second-order effects everywhere.
It meant:
most businesses had to live inside generic horizontal tools,
operational edge cases were handled by people instead of systems,
workflows were fragmented across spreadsheets, email, WhatsApp, and human memory,
software was treated as overhead rather than a core operating layer,
and only the largest or most technically exceptional firms could meaningfully encode their unique operating logic into software.
This is the part many people miss.
The old world was not divided into “software businesses” and “non-software businesses” because software mattered only to one category.
It was divided that way because only some firms could afford to make software a native competence.
Everyone else had to rent abstractions from the software industry.
Software engineering was not just important — it was scarce
Why didn’t every business become software-native earlier?
The answer is simple: because software engineering was a scarce production input.
To build meaningful custom systems, a company needed some combination of:
excellent engineers,
product managers,
designers,
architecture discipline,
internal process maturity,
patient capital,
and management that could bridge business logic with technical execution.
That stack was hard to assemble.
Even when companies had money, they often lacked talent density.
Even when they had talent, they lacked speed.
Even when they had speed, they lacked operational understanding.
Even when they had all three, software still took time.
So the modal real-world business did the rational thing:
it bought off-the-shelf tools, hired ops people to patch the gaps, and accepted a lot of organizational entropy.
That model survived because the alternative was too expensive.
This is what AI is starting to change.
AI does not just improve coding — it expands software supply
A lot of people still frame this as “developers can code faster.”
That is true, but incomplete.
The more important shift is this:
AI increases the effective supply of software engineering capability.
Not merely code generation.
Not merely autocomplete.
Not merely cost reduction.
It expands the amount of software-building capacity available to the economy.
And it does this in several ways at once:
1. It compresses the talent premium required for useful software output
Historically, there was a steep drop-off between average technical teams and elite ones.
With AI assistance, smaller teams can now reason faster, prototype faster, refactor faster, debug faster, and cover more functional surface area than before.
This does not eliminate the value of great engineers.
But it raises the output floor dramatically.
That matters because most real-world businesses never needed world-class computer science research.
They needed systems that actually fit how the business works.
2. It lowers the activation energy to build internal tools and custom workflows
In the old world, a custom internal tool often died in planning.
Why?
Because the effort-to-value ratio looked unattractive.
A workflow improvement might matter a lot operationally, but not enough to justify a months-long engineering roadmap.
AI changes that calculus.
If software can be scoped, built, iterated, and maintained with far less organizational drag, then many previously “not worth building” systems become worth building.
That widens the set of software-native possibilities.
3. It enables AI-native software studios as force multipliers
This is a particularly important piece of the thesis.
The rise of AI-native software studios means businesses no longer need to fully internalize software-building capability to benefit from it.
A small external team, paired with AI-native tooling and workflows, can deliver custom systems with speed and economics that were previously unavailable.
This is not just outsourcing with better tools.
It is a structural increase in available software production capacity for the broader economy.
In effect, the market gains a new layer of on-demand industrialized software creation.
4. It reduces the maintenance burden that historically killed customization
One reason businesses avoided custom software was not just build cost — it was maintenance anxiety.
Custom systems become legacy systems.
People leave.
Documentation rots.
Dependencies break.
Everything becomes fragile.
AI has the potential to make maintenance less dependent on institutional memory and more recoverable through machine-assisted understanding, test generation, codebase navigation, and iterative repair.
That makes customization less scary.
And once customization becomes less scary, software penetration moves deeper into operations.
The key implication: operational businesses can now encode themselves
This is where the thesis gets interesting.
A real-world business is often not fundamentally limited by demand.
It is limited by coordination.
The business works through:
routing rules,
pricing rules,
exception handling,
compliance logic,
scheduling logic,
inventory logic,
service protocols,
underwriting heuristics,
quality control loops,
customer communication flows,
workforce allocation,
and hundreds of tacit decisions made daily by experienced operators.
Historically, much of this stayed trapped in people.
In managers.
In founders.
In tenured employees.
In invisible routines.
Why?
Because encoding these things into software was hard.
But if software creation becomes abundant enough, then businesses can start systematically converting tacit operating logic into software-mediated systems.
That is what becoming software-native actually means.
Not launching an app.
Not adding dashboards.
Not buying another SaaS subscription.
It means the business increasingly runs on explicitly encoded logic rather than informal human workaround.
Why this matters more for non-software businesses than for software businesses
Software companies are already relatively optimized around software creation.
Real-world businesses are not.
That means the delta is bigger.
A SaaS company using AI to ship 30% faster is meaningful.
A logistics company using AI-native engineering capacity to redesign dispatch, pricing, exception handling, customer communication, route optimization, and fleet utilization from first principles is something else entirely.
That is not just faster product development.
That is a redesign of the firm.
In many operational sectors, the company that best encodes the business wins not because it has a prettier front-end, but because it has:
lower coordination cost,
lower error rates,
faster response loops,
better margin visibility,
better asset utilization,
higher service consistency,
and the ability to scale judgment without linearly scaling headcount.
That is why the upside is so large in the real economy.
The software layer is no longer adjacent to operations.
It becomes the operating model.
This will create a new category: software-native real-world businesses
We need better language here.
Calling these businesses “tech-enabled” is too weak.
Calling them “vertical SaaS” is often wrong.
Calling them “services businesses with software” misses the point.
The emerging category is something like:
software-native real-world businesses
These are firms whose underlying business may still involve atoms — trucks, clinics, warehouses, crews, inspectors, brokers, field agents, physical goods, or regulated services — but whose core coordination layer is designed like software from day one.
They will look different from legacy incumbents in several ways.
1. They will treat software as core operating infrastructure, not admin tooling
In a legacy firm, software often sits around the edges:
CRM, ERP, accounting, communication, reporting.
In a software-native firm, the software is where the business logic lives.
2. They will instrument operational reality much more deeply
Every workflow becomes measurable.
Every exception becomes legible.
Every delay becomes attributable.
Every decision becomes refinable.
3. They will improve through compounding system design, not just managerial heroics
Traditional businesses often depend on a few exceptionally competent humans holding complexity together.
Software-native businesses can increasingly turn those human patterns into repeatable systems.
4. They will scale without proportionate managerial thickening
A lot of operational companies become bloated because complexity grows faster than coordination capacity.
Software-native firms can push that boundary outward.
The deepest economic effect: labor previously spent on coordination gets redeployed
This is one of the least discussed implications.
Many businesses employ large numbers of people whose real job is not value creation, but coordination repair.
They:
move information between systems,
reconcile exceptions,
chase missing data,
manually route work,
update stakeholders,
check compliance steps,
and resolve process ambiguity.
These jobs exist because the business is under-encoded.
The organization cannot fully represent itself in software, so humans become middleware.
When software supply rises, more of this coordination can be absorbed into systems.
That does not mean every job disappears.
But it does mean the composition of labor changes.
A larger share of human effort can move toward:
relationship management,
judgment under ambiguity,
sales,
trust-building,
field execution,
and genuinely non-routine decisions.
The low-leverage coordination sludge becomes increasingly automatable.
This is one reason margins may expand in unexpected sectors.
Why incumbents may still struggle despite having resources
A common objection is: if this is true, incumbents should win.
They already have customers, data, and capital.
Sometimes they will.
But many will struggle because the barrier is not simply buying AI tools.
The barrier is organizational redesign.
Legacy firms often have:
fragmented systems,
entrenched workflows,
departmental silos,
vendor lock-in,
political resistance,
compliance anxiety,
and cultures that treat software as a support function rather than a strategic expression of operating logic.
So even if software creation becomes cheaper, the incumbent may still fail to re-architect the business around it.
Meanwhile, a new entrant can start with a cleaner premise:
“What would this business look like if software were abundant from day one?”
That is a far more dangerous question than most incumbents realize.
A useful analogy: electricity versus electrification
The shift here is not just “more software.”
It is closer to the difference between the existence of electricity and the electrification of industry.
At first, a new general-purpose capability gets layered onto old forms.
Later, organizations redesign themselves around it.
Factories did not become truly transformed the moment electricity appeared.
Transformation came when factory design itself changed.
Likewise, real-world businesses will not become software-native merely because AI can write code.
They become software-native when firm architecture changes:
workflows are rebuilt,
decision rights are redesigned,
tacit knowledge is encoded,
systems become integrated,
and software becomes the default medium for operational truth.
That is the real transition.
This does not mean every business becomes a software company
This point is important.
A roofing company is still in roofing.
A clinic is still in healthcare.
A freight operator is still in logistics.
A manufacturer is still making physical goods.
The core business remains grounded in reality.
But the best firms in these sectors may increasingly resemble software companies in one critical respect:
their advantage comes from how well they design and evolve their operating system.
The product is still physical or service-based.
The moat increasingly comes from the encoded intelligence of the operation.
So the claim is not “everything becomes SaaS.”
The claim is subtler and more powerful:
everything that can benefit from software-mediated coordination will move toward being software-native.
And that includes much of the real economy.
Where this shows up first
This transition will likely be strongest in industries with five characteristics:
First, high operational complexity.
Second, fragmented legacy tooling.
Third, repetitive but business-specific workflows.
Fourth, lots of exception handling.
Fifth, strong gains from better coordination.
That points toward sectors like:
logistics and freight,
healthcare administration and clinics,
construction and field services,
manufacturing operations,
insurance distribution and claims workflows,
property management,
staffing and labor marketplaces,
financial operations in traditional industries,
compliance-heavy service sectors,
and SMB roll-ups with messy back offices.
These sectors are full of latent software opportunity precisely because they were historically too messy to encode economically.
AI changes the economics of mess.
The most underappreciated unlock: the long tail can now be customized
In the old world, software economics favored standardization.
You needed large markets and repeatable use cases to justify product development.
So horizontal SaaS won large categories, while smaller niche workflows remained underserved.
But if AI-native studios and AI-native teams can build and maintain custom systems cheaply, then the long tail becomes addressable.
This matters enormously.
A mid-sized distributor with weird pricing logic.
A regional hospital workflow.
A specialty manufacturer with unique quality processes.
A contractor network with local complexity.
A niche lender with idiosyncratic underwriting.
These were all historically too specific for conventional software economics.
Now they may not be.
That means a huge amount of operational complexity that previously stayed manual can become software-native.
A second-order consequence: industry boundaries may reconfigure
Once businesses can encode operational edge more easily, the structure of competition may change.
Today, in many industries, the best operator and the best software provider are separate entities.
Tomorrow, the winning firm may combine both.
This could produce several new forms:
operators with proprietary internal software systems,
service businesses that become highly scalable through software,
roll-ups whose real edge is the AI-native operating layer,
software studios specialized by industry,
and hybrid firms that look like part operator, part software platform.
The old categories of “tech company” and “traditional company” become less useful.
A company moving freight with radically superior software-mediated coordination may be more technologically advantaged than many firms currently labeled “tech.”
The core strategic question for every real-world business
The question is no longer:
“What software should we buy?”
It is increasingly:
“What parts of our operating logic should we encode now that software creation is abundant enough to do so?”
That is a very different strategic posture.
It forces management to ask:
What is still stuck in people?
Where do handoffs break?
Where do exceptions pile up?
Where is decision-making inconsistent?
What do our best operators know that our systems do not?
Which workflows are too unique for off-the-shelf tools?
What margin leakage exists because our business is under-instrumented?
If we were rebuilding this company from scratch today, what would be software and what would remain human?
These are first-principles questions.
And they are about to become central.
The limiting factor shifts from code scarcity to judgment clarity
If this thesis is right, then the scarce input changes.
The bottleneck stops being pure software production capacity.
Instead, it becomes:
clarity of thought,
depth of operational understanding,
ability to identify what matters,
and skill in designing systems that reflect reality.
In other words:
when code becomes abundant, judgment about what to encode becomes more valuable.
That will favor founders, operators, and industry experts who understand the grain of a business at a deep level.
Because the future is not won by generating the most code.
It is won by encoding the right truths.
The bearish case
There are, of course, reasons this may play out slower than enthusiasts expect.
Physical-world operations are messy.
Human behavior is messy.
Regulation is messy.
Data quality is messy.
Integration is messy.
And software abundance does not automatically produce organizational discipline.
Many companies will build bad internal systems.
Many AI-native studios will oversell.
Many workflows will resist clean abstraction.
Many businesses will discover that their real bottleneck was not software but leadership.
So this is not a claim that every company will transform instantly.
It is a claim about directionality.
When a critical capability becomes more abundant, the set of viable firm designs expands.
That expansion alone is enough to reshape competition over time.
The strongest form of the thesis
So let’s state the thesis cleanly.
For most of modern business history, high-quality software engineering was scarce.
Because it was scarce, only a subset of firms could truly encode their operational logic into software.
Everyone else remained partially manual, partially fragmented, and structurally under-digitized.
Now, the availability of AI-native software engineers — whether inside firms or through AI-native software studios — is rising rapidly.
As a result, many businesses that were previously “non-software businesses” will increasingly become software-native real-world businesses.
Not because their end product becomes digital.
But because their internal coordination, decision-making, workflow orchestration, and competitive advantage become increasingly expressed through software.
That is the shift.
And once you see it this way, AI is not merely a tool for productivity.
It is a force that changes the feasible architecture of the firm.
Final thought
The most important companies of the next decade may not look like classic software companies at all.
They may look like ordinary businesses from the outside:
a clinic chain, a logistics network, a specialized manufacturer, a contractor platform, an insurance operator, a property services company.
But internally, they will be different.
They will run on a denser layer of encoded intelligence.
They will convert tacit operational knowledge into systems faster.
They will coordinate with less friction.
They will scale with less managerial drag.
They will learn faster because their workflows are legible.
And they will outperform incumbents not through branding alone, but through superior software-native operations.
The old distinction between “software” and “real-world” business was always partly a reflection of scarcity.
If AI dissolves that scarcity, then much of the real economy will not become software in product form.
It will become software-native in structure.
And that may be one of the biggest business changes of this era.