skip to content

Software factories are an anti-pattern

| 4 min read

Everyone’s racing to build a system of agents and automation that churns out software like a factory produces shoes or cars or candy bars. This is an absurd idea. You can’t mass produce something that isn’t mass producible.

Software development and manufacturing kinda look like the same thing. Both take raw materials and turn them into finished products. But if you actually look at the two processes they’re nothing alike.

If you make Teslas or iPhones, you want to make production of each unit as automated, scalable, and efficient as possible, because manufacturing efficiency drives margin, and because your scale is limited by throughput.

But optimization takes for granted that you have something worth mass producing in the first place. Before the manufacturing line is built, there is an entire creative process that goes into designing something worth manufacturing.

Software development is more or less entirely that creative process, because the cost of producing additional units, while not zero, is dramatically lower than for physical ones.

The same infrastructure that serves ten people can probably serve ten thousand. Most software today doesn’t actually scale through copies. It scales by iterating on architecture and expanding infrastructure.

When people talk about building software factories, they’re not talking about a more efficient way to press CD-ROMs. They’re talking about industrializing the production of code. But code is not what we should be aiming to create. A great product is. If you lose sight of that and your implicit goal becomes expanding your codebase, you’re going to have a really bad time.

Software factories look a lot to me in 2026 like personal knowledge systems looked in 2020. Each has a useful kernel: writing is thinking, so write things down. Intelligence is cheap now, so use a lot of it. We encounter these ideas and get excited and start building fancy systems around them.

The problem is, these systems are tools you build yourself, and fiddling with them feels a lot like work. It’s really easy to spend all of your time building a tool to build the thing you want to build instead of just building the thing.

A software factory pulls you towards what AI excels at, which is producing tokens. If you’re not careful, all of your attention goes to reviewing mountains and mountains of stuff that your agents produce, with no time to sleep, let alone step back and think about what you’re building and why.

Software development is a craft. The best software products are the result of hundreds or thousands of small taste-driven decisions, of opinions that are embedded into the result in ways that may or may not be obvious to the user.

As software gets cheaper and faster to build, I think the question we should be asking ourselves is: what kind of software do we want to create? What can it enable us to do that we can’t do today? How do we want using it to feel?

A better metaphor for software development is a workshop, or a kitchen, or a lab. A physical or virtual space filled with objects of beauty and taste. Books, music, tools. A place to tinker and dream and play. To develop a vision and polish the back of the cabinets. To wander and putter, dilly dally and goof off, get inspired. This is the work that only humans can do.

A factory makes the same thing over and over. Software development is never making the same thing twice. It’s one product, rebuilt and reinvented every time you touch it, unfolding into something you couldn’t specify at the start, let alone design a manufacturing line for.

If human history is any guide, the possibilities are endless when you pair human creativity with increasingly capable tools. That’s the useful way to look at a software factory: as a collection of intelligent tools. What we can create with them is mind boggling. But we can’t lose sight of the fact that the measure of a tool should be what you can build with it.

We’re heading into a world where the tools can build just about anything. The only limits left are imagination and taste. So the question isn’t how to scale the production of software. It’s how to develop the taste to know what’s worth building.