Skip to content

Month: November 2026

Do We Need Software Factories?

A lot of people are talking about software factories these days. Search for “software factory” on Google Trends or LinkedIn and you’ll see interest growing this year. There are agentic factories, AI factories, and even “dark factories”, where no human looks at the code.

[Google Trends chart: “software factory”, last 5 years]

But this is not a new idea. Not even close.

In 1968 Bob Bemer suggested that General Electric build a “software factory”: standard tools, a database of past projects, and higher programmer productivity. A year later, in 1969, Hitachi became the first company to call one of its software organizations a factory. Michael Cusumano wrote a whole book about it: Japan’s Software Factories (1991). In 2004 Jack Greenfield and Keith Short from Microsoft wrote another one, this time about patterns, models and frameworks. The idea is almost 60 years old, and every generation of software engineering rediscovers it.

So before we build another one, I want to ask a basic question. Why do we need factories at all?

What factories are for

A factory makes a fairly small number of different products in very large quantities, very efficiently. Ford didn’t build a factory to make one car. He built it to make millions of the same car. The design work is paid once, and every extra unit costs a bit less. That is the whole point. A factory beats the artisan because the artisan pays the full cost every time.

Now look at software.

We don’t need to make a million copies of a program. Software copies itself. Once it’s written, a new copy costs nothing (in software terms). Running it on another machine, for another user, in another region costs nothing either. The “production line” of software was solved decades ago. It’s called cp. Today it’s called the cloud.

So what would a software factory even produce?

And I’m not the first to ask. In 1997, Aaen, Bøttcher and Mathiassen published a paper called “The Software Factory: Contributions and Illusions”, arguing that the mass-production connotation simply doesn’t fit software.

Look at what comes out of the “software factory”

Not copies. We get those for free. What comes out is changes: a feature, a bug fix, a pull request. Every one of them is new and unique. Nobody needs two of the same PR.

And that is exactly the kind of work factories are bad at. A factory is built to repeat the same thing. Every change in software is a small design problem: understand what’s there, decide what to do, check that it’s right. That’s not production. That’s craft.

Even Hitachi wasn’t stamping out copies of one program. They were building custom systems for different customers, one project after another. They called it a factory, but what they really built was a well-organized engineering shop with standard tools and processes.

What we need is a better workshop

So I don’t think we need software factories. What we need is a better workshop.

AI gives the artisan power tools. With agents, one person can try five implementations, throw away four, and learn from all of them (that’s what my last post was about). One person can build the internal tools, scripts and small features that were never worth their time before. We will build a lot more software. But it’s still the artisan deciding what to build, and the artisan checking that it’s right.

And checking is the hard part. Generating code is cheap now. Knowing that the code does what you meant is not. Specs, tests and guardrails help a lot, but someone still needs to understand what you want the system to do. Take the artisan out and you don’t get a factory. You get a shop full of very fast robots, each one guessing what you wanted.

Words matter

So why do so many people call it a factory? Because “factory” sounds efficient, scalable and industrial. It’s a great word for a slide deck. But words come with mental models. Say “factory” and people start thinking about throughput, units per day, and taking humans off the line. That’s the wrong model for work where every item is a new design.

Let’s call it what it is: better tools for the people building software. Less exciting, maybe. But much closer to the truth.

We don’t need software factories. We need better workshops, and artisans who know how to use the new tools.