Software Factories
In 1992, a C++ developer called Jack Reeves published a short essay called “What Is Software Design?”. His argument was simple.
In manufacturing, there are two distinct activities: design and production. You design a car once. Then you produce it ten thousand times. The factory exists for the production phase. Take a design and replicate it at scale, as cheaply as possible. The entire economics of manufacturing is about the cost of replication.
Software has no production phase.
Once the code is written, copying it is free. git clone, deploy, done. There is no assembly line or raw materials consumed to reproduce the output. A “factory” would have nothing to do. Reeves’ conclusion was that all of software development is design, i.e. the source code is the design document.
The expensive, difficult, creative part is the only part.
That’s not to say we don’t design software, it’s just that the building of software is also design. It requires decisions, context, and understanding. You can’t stamp it out on a line.
This is why the factory metaphor has always failed for software. The Mythical Man Month showed that adding people to a late software project makes it later (the opposite of what happens when you add workers to a factory). And up until recently, teams tended to be split relatively evenly from junior to staff engineer, because every level of the work required human judgment. You could parallelise some of it but you couldn’t industrialise it.
Code Is Becoming Abundant
The resource that was always scarce in software, is the ability to write code. Code can now be produced by LLMs. The cost of expressing a design as working code is collapsing.
For the first time ever, software is starting to have something that looks like a production phase. There is a design (the intent, the specification, the constraints) and there is a manufacturing step (the LLM generating code that implements it). The design is still expensive. The production is becoming cheap because LLMs are automating the expression of design.
The Master Carpenter
A sensible first conclusion is that teams are going to become top-heavy.
If the grunt work of implementation can be automated, then the leverage shifts dramatically toward the people who know what to build and how to architect it. The single brilliant designer becomes highly leveraged.
In a world of abundant wood, the master carpenter does well.
We are already seeing this. There has been a huge drop in the number of junior positions in tech. The best and most brilliant engineers are earning more than ever. The industry is splitting in two: those who can think clearly about problems are worth more; those who primarily translated specifications into code are being squeezed.
This is happening now. But it’s only the first phase of the shift.
When both replication and production become cheap, something fundamental changes in the economics.
Enter the Software Factory
If software can be produced reliably and quickly based on specs, data and insight, then the software itself is no longer the valuable part. It is the output of a production process. The value lives upstream, in the thing that produces it.
A software factory is a set of patterns and recipes, combined with domain-specific knowledge and customer context, that produces a piece of software. The formula looks something like:
The code that comes out the other end is a rendered artifact which is specific to the customer and the problem they face. The artifacts can be regenerated, modified, or replaced, because the factory that produced it still exists and still understands the domain.
Loveable is an early version of a software factory. It enables people who cannot code to produce websites and web applications. The user brings the intent and the context. The factory brings the patterns, the knowledge of what good software looks like, and the LLM-powered production capability. Out comes a working product.
Loveable is one instance of the pattern. But the pattern itself is about to reshape the whole software market.
The SaaS Problem
Consider how B2B software works today. A SaaS company builds a single product and rents access to it. Every customer uses essentially the same software, with some configuration on top. The economics are compelling for the vendor: build once, sell many times. The customer accepts the trade-off: you get software that mostly fits your needs, you don’t own it, and you pay for it forever.
This model made sense when building custom software was prohibitively expensive. The SaaS vendor could amortise the enormous cost of development across thousands of customers. No individual company could justify building their own version.
Software factories break that equation.
If a factory can produce bespoke software for a specific customer which is tailored to their data and their workflows, etc. at a cost comparable to or lower than a SaaS subscription, then the traditional SaaS model has a serious problem.
As a buyer, you can now purchase hyper-personalised software that you own. You can modify it as you choose or move away from the original provider. You’re not locked into someone else’s product roadmap or your vendor’s pricing decisions. The switching costs that protect SaaS businesses can’t exist if the customer owns the code.
This won’t happen everywhere at once. Horizontal platforms like Slack, Stripe and large-scale data infrastructure providers have network effects and ecosystem integrations that a factory can’t easily replicate. But vertical B2B SaaS is going to get eaten by this new paradigm. The factory model is simply better for both sides.
Where is the IP?
In the SaaS model, the code is the moat. You’re renting access to it. The vendor’s competitive advantage is the software itself, i.e. the accumulated codebase that took years and millions of dollars to build. The code is the asset.
In the software factory model, the code is the commodity output. Every customer gets different code. No single codebase is the product. The asset is the factory, it includes the patterns, the domain knowledge, the understanding of what good looks like in this specific vertical.
The IP is not in the code the factory produces. It’s in the factory itself. And that IP is not accessible from the output because the output is specific to each customer and the problems they face. You can reverse-engineer one customer’s software and learn nothing about the factory that made it, just as you can disassemble one Toyota and learn relatively little about the Toyota Production System.
This is a structurally defensible position. The factory owner accumulates knowledge with every customer engagement and each deployment teaches the factory something new about the domain.
The Shape of What’s Coming
The transition is likely to be uneven and messy. SaaS companies won’t disappear overnight. But the pressure is structural because the fundamentals of what it means to build software have changed.
Software factories will appear first in verticals where SaaS was always an awkward fit, industries with heavy regulation, unusual workflows, or deep customisation needs. Healthcare, legal, financial services, defence, insurance, research. Places where “one-size-fits-all” was often a painful compromise.
At first, companies building these factories will look like agencies. They’ll produce bespoke output per client without a standardised product to point at. Their team will work closely with each customer to understand their specific needs. From the outside, indistinguishable from a consultancy or a custom development shop.
Agencies are valued poorly (compared to SaaS) because their revenue is linear with headcount. The value of their compounding asset is limited as primarily they sell time (labour).
Software factories look like agencies but accumulate IP like product companies. Every customer engagement makes the factory smarter. As domain knowledge deepens, patterns improve and the recipes start to compound. You’re selling the output of a production system that gets better with every use.
Jack Reeves was right that all of software was design. He just couldn’t have anticipated a world where the design could be automatically rendered into code. A capability which is going to completely upend the way software is created.
The software factory is here.