← ALL POSTS

What the Hell Are AI Software Factories?

The term is fifty-seven years old and has meant four different things. The newest one is the first where the workers aren't people.

WESSCOBY · NOV 2026 · 7 MIN READ

"AI software factory" is everywhere right now. Somebody's building one, selling one, or telling you your team should become one.

The idea goes like this. You set up a group of AI agents and give each one a role you'd recognise from a product team: one plans, one designs, one writes the code, one tests it, one reviews it. They hand work to each other and talk to each other about it, and a project goes from a spec to a pull request, and in the more ambitious setups past the pull request into deployment and whatever comes after. People mostly stand at the two ends.

The "AI" part is new. The "software factory" part isn't. The term has been around since 1969, and it has meant four different things. Each version answered the same question: where should the human stand while software gets made? Until this one, every answer kept a human on the code.

Four software factories. 1969: the factory was the process (Hitachi Software Works); people work on every line of code. 2004: the tooling (Greenfield and Short, Microsoft); people work on the models the code is generated from. 2017: the pipeline (Kessel Run, US Air Force); people work on writing and reviewing the code. 2026: a team of agents (StrongDM, after ChatDev and MetaGPT); people work on the spec and the check. In the first three a person writes the code; in the last, agents write it.

1969: the factory was the process

Hitachi opened its Software Works in 1969, the first software organisation to call itself a factory. NEC, Toshiba and Fujitsu followed with their own in the 1970s. Michael Cusumano wrote the history in Japan's Software Factories (1991).

There were no robots. These were buildings full of programmers working under factory discipline: standard methods, reusable components, measured output, defect tracking and a lot of training. The idea was that software didn't have to be a craft. If you made similar systems again and again, you could make them the way you make anything else on a line.

It worked for the kind of software they made, mostly large custom systems with plenty of overlap between them. The factory was the process. People still wrote every line.

2004: the factory was the tooling

In 2004 Jack Greenfield and Keith Short at Microsoft published Software Factories: Assembling Applications with Patterns, Models, Frameworks, and Tools.

Their factory was a kit. You described a family of similar applications as a product line, wrote domain-specific languages and models for that family, and generated much of the code from those models. A developer worked in the model, and the tools filled in the rest.

It mostly faded. Keeping the models right turned out to be harder than keeping the code right, and the generated code still had to be read whenever something broke. The factory was the tooling. People moved up a level to the models, but they never really left the code.

2017: the factory was the pipeline

In 2017 the US Air Force started Kessel Run, and "software factory" became a phrase in defence procurement. Many more followed across the services, along with shared platforms such as Platform One.

Strip away the branding and a DoD software factory is a DevSecOps platform: CI/CD, hardened containers, automated security scanning, and the paperwork done once so a team doesn't wait a year for permission to deploy. That last part was the real breakthrough, and it was about permission more than technology.

The factory was the pipeline. People still wrote and reviewed the code. The factory made sure what they wrote could ship.

That version is already changing. In October 2026, Col. Brian Viola told Air & Space Forces Magazine that "as far as organic delivery for Kessel Run, we're no longer a software factory." It has moved from Airmen writing the code to a contractor-led model.

2026: the factory is a team of agents

This is the version you're hearing about now.

An AI software factory is a system where coding agents do the production work. A spec, ticket or scenario goes in. Agents with different jobs plan it, write it, test it, review it and fix it, handing work to each other along the way. Software comes out. People write the inputs and judge the outputs.

The role-based shape has been around a little while. In 2023 two research projects tried it: ChatDev had specialised agents build software through conversations with each other, and MetaGPT gave agents different roles and ran them as an assembly line, following written operating procedures. Even the researchers reached for the factory floor.

The far end of this has a manufacturing name too: the dark factory, a plant that runs with the lights off because nobody is on the floor. Dan Shapiro's five levels of AI coding borrow from the levels of driving automation and run from "spicy autocomplete" to "the dark factory".

In February 2026, StrongDM's AI team published the most extreme version I've seen: a software factory run by a team of three, where agents write, test and ship production code. Two of their rules:

Code must not be written by humans.

Code must not be reviewed by humans.

Simon Willison called the second one the most interesting, and it's also the one that makes it a factory. If a person reads every diff, you have a fast typist with a human bottleneck. If nobody reads the diffs, something else has to tell you the software is right. That something is the factory.

A definition that fits all four

A software factory is a system for producing software in which the unit of human work is not the line of code.

In 1969 people worked on the process. In 2004 they worked on the model, and in 2017 on the pipeline. In 2026 they work on the spec and on the check.

What changed this time is who's on the line. Every earlier factory still had people writing the code, and the factory organised them. This one doesn't need them for that part.

What a factory is not

An agent in your editor isn't a factory. That's you, working faster.

A long prompt isn't a factory either, and neither is a demo where an agent builds a to-do app while you watch. Nor is a handful of agents with job titles, on its own. A factory has the same parts a real one has:

  • Inputs precise enough to build from: specs, acceptance criteria, scenarios.
  • Stations with a defined job each: plan, implement, test, review, merge.
  • Inspection that doesn't depend on the worker grading its own work.
  • Throughput: it runs while you're not watching, and you can measure what comes out.

If you have to sit there and steer it, you have a power tool. That's useful. It isn't a factory.

The hard part is inspection

Generating code is the cheap part now. Agents will write as much as you let them.

Knowing whether that code is right is the expensive part, and it's where StrongDM, the most complete example I've read about, puts its effort. Their scenarios live outside the codebase, like a holdout set in model training, so the agents can't write code that only passes the tests they already know. They built behavioural clones of the third-party services they depend on (Okta, Jira, Slack, Google Docs and others), so the whole thing can be checked end to end without touching the real ones.

An AI software factory as a line: a spec written by a person goes through agent stations (plan, implement, test, review, merge), each with one role, to a result judged by a person. Below the line, an inspection stage checks the work against scenarios kept outside the codebase and clones of third-party services, and what fails goes back to the line.
The inspection stage follows StrongDM's description of its factory.

That's where the human went. The job moved from writing code to deciding what "correct" means, writing it down in a form a machine can check, and owning the result when the check was wrong.

When one pays off

The 1969 lesson still holds: factories pay off on repetition. Hitachi's factory worked because it built similar systems over and over. An agent factory works best for the same reason: a codebase with clear patterns, a backlog of well-defined tickets, and a good way to check the output.

If every piece of work is new, ambiguous and hard to verify, a factory will produce a lot of confident, wrong software very quickly.

So the useful question isn't whether you need an AI software factory. It's how much of your work is repeatable, and whether you can check it without reading it. If you have a good answer to the second part, you're closer to having one than you think.

Sources

  • Cusumano, M. A. (1991). Japan's software factories: A challenge to U.S. management. Oxford University Press. academic.oup.com/book/52424
  • Greenfield, J., & Short, K. (2004). Software factories: Assembling applications with patterns, models, frameworks, and tools. Wiley. softwarefactories.com
  • Hong, S., et al. (2023, August 1). MetaGPT: Meta programming for a multi-agent collaborative framework. arXiv. arxiv.org/abs/2308.00352
  • McCarthy, J. (2026, February 6). Software factories and the agentic moment. StrongDM AI. factory.strongdm.ai
  • Qian, C., et al. (2023, July 16). ChatDev: Communicative agents for software development. arXiv. arxiv.org/abs/2307.07924
  • Shapiro, D. (2026, January 23). The five levels: From spicy autocomplete to the dark factory. danshapiro.com
  • South, T. (2026, October 16). Q&A: No longer a software factory, what's next for Air Force's Kessel Run? Air & Space Forces Magazine. airandspaceforces.com
  • Willison, S. (2026, February 7). How StrongDM's AI team build serious software without even looking at the code. Simon Willison's Weblog. simonwillison.net