Every fast-moving industry throws off a flurry of new terms. If my X timeline is any indication, “software factory” is a winner. So what’s that about?
If you were to imagine how to transpose the status quo of “software development” into an AI world, you would come up with a software factory. In the “old” world the stakeholders (clients, users, C-suite, founder, bored investor…) would come up with feature requirements or bugs that would then be articulated and discussed, eventually prioritised, and find their way onto a developer’s or designer’s desk. They would work on it, there would be reviews, QA, some more discussions, changes etc., and at some point it would finally find its way to production and into the hands of users (who by then would have forgotten that they wanted it in the first place).
A software factory is trying to mimic that process, but instead of people we have agents. Agents that collaborate and follow a predetermined process to get to an outcome (the feature being completed and live).
It makes sense. BUT it is overkill in most cases. The reason we had the old process with its many steps, meetings, backlogs and dev/staging/production in the first place was that software engineering was bloody hard and took time to do properly without seeing a new feature break something, or ten new bugs spawning from the one that was fixed. To remedy that we created rules and processes, and in doing so we made software development more complex in appearance and, most importantly, expensive. All these steps added time, and even simple features would now legitimately take days if not weeks to be “done”.
Software factories carry that perceived complexity brilliantly, especially as half of my X timeline is discussing what on earth a software factory might actually be. To some extent they also carry the cost: by design they are not token efficient, with common double handling of context etc. between agents, in a very human way (remember those meetings where half the attendees didn’t need to be there?).
At least software factories do get the speed right over the old way, as it’s hard to beat a handful of agents burning a couple hundred thousand tokens vs. half a dozen software professionals debating how many story points the feature should be and whether we should work on it this week or never.
Arguably, software engineering is now “solved”, and as its cost races towards zero we probably don’t need so many processes in place to check that the machine could indeed do machine things.
That last point is only true if the entire codebase was built by the machine, i.e. not some legacy app with a decade of complexity and bugs piled upon bugs, but a fresh application built from the ground up by a capable agent.
That leads us to the one situation where I see a software factory as a relevant solution. An established product with many, many years of layered complexity and features. With an existing team struggling to make sense of it all. In that case the best solution would be to start from scratch. Falling short of that, setting up a software factory to hand the code-writing over to agents would, indeed, make sense.
So in short, humans were always pretty bad at writing code because software gets really complex really quick. Agents, on the other hand, love it and are getting really good at it. A software factory is a framework that assumes that the code is hard and puts systems in place to make humans feel better about it.