For decades, software was expensive because software was difficult to build.
A serious business application required programmers, designers, database engineers, system administrators, QA teams, project managers, security specialists and months — sometimes years — of development.
That reality created some of the largest and most profitable companies in history.
Microsoft could sell Office to hundreds of millions of users. Adobe could build an empire around creative software. Salesforce, Oracle and SAP could charge companies enormous recurring licensing fees for systems that would have been prohibitively expensive for most businesses to reproduce themselves.
Software had extraordinary margins because creating a serious alternative was extraordinarily expensive.
But what happens when that cost collapses?
What happens when three or four capable people in Turkey, Poland, Brazil, Vietnam or India can build software that would once have required an entire engineering department?
What happens when a single experienced developer can manage several AI coding agents simultaneously?
And what happens when millions of companies realize that paying $50, $100 or $200 per employee every month for software is no longer the only realistic option?
We may be approaching that world much faster than most people realize.
And if code becomes almost free, the consequences may extend far beyond programmers becoming more productive.
The entire economic structure of the software industry could begin to change.
Code Is Not Literally Free. But That Is Not the Point.
Of course, code is not actually free.
Someone still has to understand the problem.
Someone has to design the product.
Someone has to make architectural decisions, test the system, secure it, operate the infrastructure and deal with users.
AI-generated code can be wrong.
Sometimes spectacularly wrong.
But technologies do not need to reduce a cost to zero in order to transform an industry.
Digital photography did not need to make photography completely free to destroy Kodak's old business model.
The internet did not make publishing completely free, but it reduced publishing and distribution costs enough to create millions of publishers.
YouTube did not make video production free. It made distribution cheap enough for millions of creators to compete for attention previously controlled by television networks.
The important question, therefore, is not whether software becomes free.
The important question is:
What happens if producing software becomes 80% or 90% cheaper?
That is where the disruption begins.
If something previously required 50 engineers and two years, but eventually requires five engineers and six months, you do not simply get the same software industry with more productive programmers.
You get entirely new economics.
Markets previously too small to justify a software company suddenly become attractive.
Local competitors suddenly become viable.
Companies can afford to build software for extremely specific industries.
And entrepreneurs can experiment with ideas that previously would have required millions of dollars in financing before the first customer even arrived.
The Real Product Was Never Just the Code
Consider something as ordinary as Microsoft Word.
From a user's perspective, Word is not conceptually mysterious.
You type text.
You format paragraphs.
You insert images and tables.
You collaborate.
You add comments.
You export a PDF.
You save documents.
Excel is considerably more complicated, of course.
So are PowerPoint, Outlook, SharePoint and the enormous infrastructure surrounding Microsoft 365.
Reproducing the entire Microsoft ecosystem — including decades of file compatibility, enterprise management, security, integrations and edge cases — is still an enormous engineering problem.
But a competitor does not necessarily need to reproduce all of Microsoft Office.
That is the important part.
A construction company may use only a fraction of Excel.
A law firm may use only a fraction of Word.
A medical clinic may need documents, spreadsheets and workflows that are completely different from those of a logistics company.
Historically, it was economically rational to give everyone the same giant general-purpose application.
Building hundreds of specialized alternatives would have been too expensive.
AI changes that calculation.
A small company does not have to build "the next Excel."
It can build:
Excel for construction companies.
Or Word for law firms.
Or a document platform specifically for hospitals.
Or a CRM specifically for hair clinics.
Or an ERP designed entirely around textile manufacturers.
Once software development becomes dramatically cheaper, specialization becomes dramatically more attractive.
The Five-Person Software Company
The most interesting company of the AI era may not be the trillion-dollar AI laboratory.
It may be the five-person company.
Imagine a team consisting of:
a founder who deeply understands an industry,
two strong developers,
a product/design person,
and someone responsible for distribution.
Behind them are coding agents capable of generating interfaces, APIs, database migrations, tests, internal tools, documentation and routine infrastructure.
One engineer might increasingly operate several development processes simultaneously.
Instead of spending hours manually implementing every component, developers begin behaving more like technical directors.
Describe.
Generate.
Review.
Test.
Correct.
Deploy.
Repeat.
This is sometimes dismissed as "vibe coding," but the important economic effect goes far beyond inexperienced people asking AI to generate websites.
Experienced developers using AI well can dramatically expand the amount of software a small team can produce.
And once that happens, minimum viable company size begins to fall.
We Are Already Seeing Early Signs
It is still early, and many AI-built products will disappear just as quickly as they appeared.
But the direction is becoming difficult to ignore.
Consider just a few examples.
Base44 began as an unusually small operation around natural-language software creation and was acquired by Wix for roughly $80 million only about six months after launch. It had grown to a team of just eight people at the time of the acquisition.
Rork, built by two founders, lets users create mobile applications through natural-language instructions. After a viral launch moment, the company reportedly generated roughly $100,000 in revenue within five days.
Stanley, an AI product inside creator platform Stan, was reportedly vibe-coded by its founders in approximately 14 days. The product later crossed $1 million in annual recurring revenue and expanded further afterward.
Payout, a mobile application highlighted by founder Connor Burd, was built in roughly two weeks using an AI-assisted development workflow — compared with the six to eight months he said similar development previously took him.
Respiro is perhaps even more revealing. Its creator was a non-technical project manager who had never written code before; using Claude Code, he built and shipped a stress-management application to the App Store in roughly six weeks.
CheckHowMuch.sg, a Singapore property-intelligence website, reportedly grew into a roughly 9,700-page data product using Claude Code without a conventional development team.
And veteran Microsoft engineer Dave Plummer recently demonstrated another side of the phenomenon by using a detailed specification and Claude Code to create a working cross-platform Task Manager prototype in roughly four and a half hours. This was a prototype rather than production software — an important distinction — but the compression of implementation time is still remarkable.
None of these examples means one programmer can suddenly reproduce thirty years of Microsoft engineering.
That would be the wrong conclusion.
The important change is that people can now attempt categories of software that previously would have been economically inaccessible to them.
That boundary keeps moving.
You Can See the Same Pattern in Smaller Independent Products
The change becomes even more interesting when we stop looking only at venture-funded startups.
Consider FileHugger.com.
It is not trying to recreate Adobe as a corporation. Instead, it attacks hundreds of small file-related problems individually: PDF operations, document conversion, image processing, audio and video conversion, OCR, metadata inspection and data-format transformations. The platform currently presents more than 100 individual tools.
Twenty years ago, assembling that breadth of functionality into one polished web product would have represented a substantial software project.
Today, open-source libraries, browsers, cloud infrastructure and AI-assisted coding radically reduce the human effort needed to put the pieces together.
Or consider EveryQuake.com.
It combines earthquake catalogs from organizations including USGS, ISC, AFAD, Kandilli Observatory and EMSC into an interactive earthquake archive with mapping, filtering and analysis tools.
Again, AI does not magically create the earthquake data.
It does something economically just as important.
It makes building the infrastructure around that data cheaper:
data ingestion,
normalization,
interfaces,
maps,
filters,
APIs,
localization,
analysis screens,
administration,
testing,
documentation.
And then there is Optonance.com, which moves into an entirely different category.
Optonance is an optical-design platform with capabilities including sequential and non-sequential ray tracing, MTF and PSF analysis, optimization, tolerancing and physical-optics workflows.
This is not another AI-generated to-do list.
It belongs to a category traditionally dominated by highly specialized engineering software developed over many years.
The important observation is not that a tiny newcomer instantly reproduces every feature, edge case and validated calculation accumulated by a mature engineering suite over decades.
It does not need to.
The remarkable thing is that small AI-assisted teams can increasingly enter such categories at all.
Five years ago, an entrepreneur looking at a sophisticated engineering platform might have said:
"We could never build that."
Today the question is increasingly:
"Which part should we build first?"
That is a profound difference.
Software May Become Local Again
One of the most underestimated consequences could be the localization of software.
Today, businesses all over the world send enormous amounts of money abroad through software subscriptions.
Microsoft 365.
Adobe Creative Cloud.
Salesforce.
HubSpot.
Atlassian.
ServiceNow.
Oracle.
SAP.
Dozens of other platforms.
A Turkish company might use an American CRM, an Australian project-management platform, an American design suite and a German ERP system — all priced partly around global markets and large corporate structures.
Why?
Often because building competitive domestic alternatives has historically been too expensive.
Imagine that development costs fall dramatically.
Suddenly the economics change.
A Turkish software company does not need to defeat Microsoft globally.
It might only need 10,000 Turkish businesses.
And it can build specifically around those businesses.
Turkish accounting systems.
Turkish banks.
Local payment providers.
E-invoicing.
Local tax rules.
Domestic regulations.
Turkish-language AI.
Local support.
Domestic hosting.
The same logic applies everywhere.
Brazilian software for Brazilian companies.
Indonesian software for Indonesian businesses.
Arabic enterprise platforms optimized for Gulf markets.
European software designed specifically around European regulation.
Indian applications deeply integrated with Indian payments and taxation.
For the last three decades, software globalization strongly favored a small number of companies capable of selling the same product everywhere.
AI may partially reverse that process.
Why Pay $100 Per User If We Can Build Our Own?
There is another possibility that should make SaaS companies uncomfortable.
For twenty years, the answer to the classic build versus buy question has increasingly been:
Buy.
Need CRM?
Buy Salesforce.
Need project management?
Buy another subscription.
Need analytics?
Subscribe.
Need electronic signatures?
Subscribe.
Need scheduling?
Subscribe.
Need forms?
Subscribe.
Need dashboards?
Subscribe.
Need an internal approval workflow?
Find another SaaS product.
The economics made sense.
Imagine a company needs a workflow application that costs $2,000 per month.
That is $24,000 every year.
Building an equivalent application internally might historically have cost $150,000 or more, plus ongoing maintenance.
Buying was obvious.
But suppose an experienced developer working with coding agents can create exactly what the business needs in several weeks.
No unnecessary features.
No per-user pricing.
No third-party workflow compromises.
No waiting six months for a vendor to implement one specific feature.
Suddenly the calculation becomes less obvious.
And SaaS companies acquire a new competitor that almost nobody talked about five years ago:
their own customers.
We Could See Software Deflation
Software pricing has spent years moving upward.
$10 per employee.
$30 per employee.
$50 per employee.
$100 per employee.
Then another subscription.
And another.
And another.
Many companies now maintain enormous SaaS stacks consisting of dozens or even hundreds of products.
Those prices have been supported by several things:
development costs,
switching costs,
distribution,
brand,
and relatively limited competition.
AI attacks at least one of those foundations directly.
The cost of creating a competitor.
What happens when every moderately successful SaaS product attracts 30 AI-assisted alternatives?
What happens when somebody can reproduce the core workflow of a $500-per-month niche SaaS product in weeks?
Software could begin experiencing deflation.
A product charging $100 might eventually charge $30.
A product charging $30 might become $10.
A product charging $10 might become free.
And some products might simply stop existing as independent products.
They become features.
Eventually, some features might become prompts.
The Biggest Opportunity May Be Boring Software
When people imagine AI startups, they usually imagine futuristic products.
Robotics.
AGI.
Autonomous agents.
Synthetic biology.
AI companions.
But one of the largest entrepreneurial opportunities may be much less exciting.
Replacing boring software.
Accounting programs.
Inventory software.
Procurement systems.
Scheduling software.
Document management.
Hotel management.
Construction software.
Manufacturing ERP.
Clinic management.
Fleet tracking.
Insurance administration.
Government software.
Warehouse software.
Industry-specific CRM systems.
There are thousands of industries still running software created years or even decades ago.
The interface is terrible.
The workflow is terrible.
The API barely exists.
Nobody likes the product.
Yet customers continue paying.
Why?
Because replacing it was expensive.
That is an enormous competitive moat.
And AI is beginning to dig underneath it.
A market worth $10 million per year may not justify a traditional venture-backed company employing 70 people.
It could be an extraordinary business for seven people.
A niche worth $2 million might be unattractive to a conventional software company.
It could make two founders extremely successful.
This is why AI could result not only in bigger technology companies, but in far more technology companies.
Instead of 20 Giants, We Could Get 100,000 Smaller Companies
This leads to an interesting possibility.
Imagine a giant software company employing 20,000 people.
Historically, competing with it meant building another substantial organization.
You needed capital.
Recruiters.
Engineering departments.
Management layers.
QA.
Design.
DevOps.
Product managers.
Sales.
Support.
The organization itself became one of the largest barriers to entry.
AI potentially changes the unit of competition.
Instead of one new 20,000-person competitor appearing, perhaps the incumbent faces:
200 companies with 50 employees,
1,000 companies with ten employees,
and thousands more with two or three.
None reproduces the entire incumbent.
Each attacks a profitable slice.
One attacks PDF editing.
Another attacks presentation generation.
Another attacks spreadsheets for financial analysts.
Another attacks CRM for dentists.
Another attacks warehouse workflows.
Another attacks optical engineering.
Another attacks file conversion.
Another attacks local accounting.
This is much harder to defend against.
The future may not bring one company that kills Microsoft Office.
It may bring 10,000 companies that each remove one reason to use it.
Big Tech Might Become Smaller — and Bigger
There is a paradox here.
AI could weaken Big Tech.
And make Big Tech even more powerful.
Thousands of new software companies still need infrastructure.
They need cloud computing.
AI models.
Storage.
Payments.
Authentication.
Email delivery.
Advertising.
Search traffic.
Mobile distribution.
So perhaps Microsoft faces thousands of new productivity competitors while simultaneously selling them Azure infrastructure and AI models.
Perhaps Amazon does not care which SaaS application wins because dozens of competitors run on AWS.
Perhaps Google loses parts of traditional software categories while making money from cloud infrastructure, advertising and AI.
In other words:
the application layer may decentralize while the infrastructure layer concentrates.
That may be one of the defining contradictions of the next decade.
If Code Becomes Cheap, What Becomes Expensive?
If anyone can build software, software does not become worthless.
Value simply moves.
Distribution becomes more important.
Brand becomes more important.
Trust becomes more important.
Proprietary data becomes more important.
Community becomes more important.
Network effects become more important.
Customer relationships become more important.
Domain knowledge becomes more important.
A programmer may increasingly be able to create something resembling a CRM.
That does not mean 20,000 companies will trust it with their customer databases.
A team may produce a sophisticated engineering application.
Professional engineers still need confidence that its calculations are correct.
An AI agent can help somebody create an accounting platform.
That does not automatically give them knowledge of tax law.
AI makes implementation cheaper.
It does not automatically make reputation, expertise or distribution cheap.
This may force software companies to discover something uncomfortable:
their code may never have been their strongest moat.
Domain Experts May Become the New Software Founders
Consider two people.
One is an excellent programmer who knows almost nothing about the dental industry.
The other has operated dental clinics for fifteen years but only has basic technical knowledge.
Twenty years ago, the programmer had an enormous advantage when creating software.
In an AI-assisted world, the balance changes.
The clinic operator knows exactly where money is being wasted.
Which forms employees repeatedly fill out.
Which reports are missing.
Which workflows cause mistakes.
Which integrations clinics need.
Which features existing products get wrong.
AI increasingly helps translate that domain knowledge into working software.
The programmer can learn dentistry.
But AI can also help the dentist learn enough software development to build.
Implementation becomes less scarce.
Understanding the problem becomes more scarce.
That may lead to a strange new generation of founders:
Doctors building medical software.
Lawyers building legal software.
Accountants building financial software.
Construction managers building construction tools.
Engineers building specialized engineering applications.
The world's domain knowledge suddenly becomes much easier to turn into software.
But Vibe Coding Has a Serious Problem
There is a danger in taking this argument too far.
AI is extraordinarily good at making unfinished software look finished.
A beautiful interface appears.
Authentication works.
The database connects.
Payments process.
Everything looks impressive.
And underneath it may be terrible architecture.
Security vulnerabilities.
Broken permissions.
Race conditions.
Unvalidated inputs.
Dependency problems.
Scaling issues.
Data-loss scenarios.
Zero disaster recovery.
No tests.
AI can create thousands of lines of plausible code faster than a human can properly inspect them.
The first 70% or 80% of a product can now feel almost magical.
Production software is different.
Someone still has to understand what the system is doing.
This is why experienced software engineers are unlikely to simply disappear.
Their role may change.
Less bricklayer.
More architect.
Less manual implementation.
More specification, review, testing and engineering judgment.
AI can build walls very quickly.
Someone still needs to know whether the building will remain standing.
The Billion-Dollar Company With Twelve Employees
For decades, company revenue and employee count were strongly related.
A company serving millions of customers required enormous organizations.
AI weakens that relationship.
Lovable offers an early illustration of what extraordinary software leverage can look like. The vibe-coding company passed $100 million in annual recurring revenue only eight months after launch while reporting just 45 full-time employees at the time.
That does not mean tomorrow's billion-dollar businesses will literally have five employees.
But the direction matters.
If an AI-native company can generate several times more revenue per employee than a traditional software company, investors and founders will notice.
Eventually the question may stop being:
"How many people should we hire?"
and become:
"Why do we need to hire anyone for this task at all?"
That creates potentially extraordinary companies.
It also creates uncomfortable social questions.
AI democratizes creation.
It does not necessarily democratize ownership.
A twelve-person company producing $100 million in annual profit could create extraordinary wealth for a tiny number of owners.
That may become one of the great economic debates of the AI era.
Software Used to Be Something You Bought
Perhaps the deepest change is philosophical.
For decades, software was a product.
Someone built it.
You bought it.
You adapted your work to it.
AI could reverse that relationship.
Imagine telling a computer:
"Create an internal application where our warehouse managers see delayed shipments, upload photographs, contact the relevant supplier and automatically inform customers when the expected delivery date changes."
The application appears.
Your employees use it.
Three months later the workflow changes.
You describe the change.
The software changes.
At that point, software begins looking less like a manufactured product and more like a generated resource.
Today companies generate documents.
Tomorrow they may generate applications.
Today an employee creates a spreadsheet because no software exists for a specific problem.
Tomorrow they may simply create the software.
If that future arrives, enormous portions of today's SaaS industry start looking very different.
Code Is Becoming Abundant
The Industrial Revolution made physical power cheap.
The internet made information distribution cheap.
AI may make intellectual production cheap.
Code is one of the first places where we can clearly watch this happening.
And economics tells us something important about abundance:
When something stops being scarce, value moves somewhere else.
If code becomes abundant, value moves toward:
ideas,
distribution,
trust,
customers,
data,
domain expertise,
and execution.
That could produce an outcome very different from the AI future normally discussed.
AI is often described as a technology that will create a handful of gigantic winners.
At the infrastructure layer, that may be exactly what happens.
Training frontier AI models and operating enormous computing infrastructure requires extraordinary amounts of capital.
But at the application layer, the opposite may happen.
We could be approaching the greatest fragmentation of the software industry in history.
Thousands of specialized SaaS products.
Local alternatives to global platforms.
Tiny companies serving profitable niches.
Businesses building their own internal software.
Domain experts becoming founders.
Two-person companies operating internationally.
Software markets previously too small to justify development suddenly becoming viable.
The age of the 50,000-person software corporation is probably not ending.
Microsoft, Google, Adobe, Oracle, Salesforce and SAP are not going to disappear because Claude or another AI model can write code.
They possess decades of trust, distribution, integrations, data, customers and infrastructure.
But they may soon share the software economy with something that historically could not exist at this scale:
millions of extremely small software producers.
The five-person multinational.
The two-person SaaS company.
The accountant who builds an accounting platform.
The engineer who builds engineering software.
The company that simply generates its own internal applications instead of subscribing to another SaaS product.
And that may turn out to be one of AI's most disruptive effects.
Not that artificial intelligence learns to write software.
But that the cost of turning an idea into software collapses so dramatically that almost anyone with enough knowledge of a problem can suddenly afford to compete.
For the last forty years, code was one of the software industry's greatest barriers to entry.
We are now entering a world where code itself may become one of the cheapest parts.
The question is no longer just:
Who can build software?
Increasingly, the answer may be:
Almost anyone.
The much bigger question is:
What happens to the software industry when they do?
Top comments (0)