AI software factories: five setups, one honest limit
Aggiornato
Foto illustrativa
What an AI software factory actually is
An AIsoftwarefactory is the next level of autonomy for coding agents. Instead of guiding an agent through one GitHub issue or Jira ticket at a time, with a human in the loop during planning, building, and validating, you hand a batch of work to a system that plans, builds, and validates on its own.
That shift became realistic as large language models, coding agent harnesses, and the surrounding systems improved. Medin is explicit that the factory is not the pipe dream of managing your entire application and shipping everything straight to production; he calls it more nuanced than that.
He lays out five common types and the trade-offs of each: the dark factory, the fleet factory, the PR factory, the release factory, and the self-improving factory.
The darkfactory is the pipe dream. You send in a request that isn't even very structured, and the system handles planning, building, reviewing, and merging straight to production with no human review. Medin calls it the most efficient way to run an application or business.
He doesn't think we will ever get there. The fundamental problem is intent: you won't communicate what you want perfectly 100% of the time, and a mistake in communicating intent leads to a bad implementation shipped straight to production. That problem doesn't depend on how capable the underlying model or coding agent is, because it comes down to getting on the same page with it.
He ran a public darkfactory experiment earlier this year, with separate review agents and auto-merge straight to production. It worked reasonably well, but small problems kept showing up in the application simply because he didn't know something.
Fleet factory: the dark factory that works
The fleetfactory is, in Medin's words, the dark factory that actually works. The key difference is what you try to build, not how it works under the hood: the workflow is the same, but instead of managing the entire application, the factory focuses on parts with a very clear goal and a clear way to measure success.
Examples he gives are migrations, refactors, and maintenance, where describing what the agent is shooting for and how it will validate the result is easy. He names it after Spotify's terminology, because Spotify built its own fleetfactory called Honk. Spotify reports more than 2.5 million automated maintenance PRs merged to date, and Medin notes that Spotify is not building a dark factory: the factory is not managing their entire platform.
PR factory: review every pull request
The PR factory is the opposite of the fleet factory, because you review every single pull request. That also enables teams to trust the factory with more, including work that requires a lot of judgment calls: if intent wasn't communicated properly up front, you can validate it while reviewing the pull requests before anything merges, even to a staging environment.
It is also the only type focused on one issue at a time. Multiple issues can go through the build loop in parallel, but review stays per issue rather than batched in a staging environment.
Medin points to a METR study from the start of the year: about one in two test-passing agent PRs in open-source projects weren't merged by maintainers. He attributes that to the people building the PRs either not understanding the open-source project and its direction or not communicating their intent properly, which he says falls into the same problems as the dark factory.
Release factory: batches of 10 to 20 tickets
The releasefactory packages a set of tickets to build fully autonomously in batch. Medin flags a common misconception: people think release means shoving an entire epic into the factory, which he says is really not the case. He generally recommends bundling somewhere between 10 and 20 tickets into what he calls a work order.
The factory splits that work order into issues and handles dependency mapping, so it can figure out which work items it can handle in parallel with the core build loop. Each loop picks an issue based on a priority list and goes through planning, implementing, and validating. A fresh agent session handles each step, and the builder never grades its own work; separate agent sessions do the reviewing and app-checking.
How many tickets you bundle depends on complexity and what you're building: it can be a larger feature split up, or a mix of smaller features and bug fixes.
Self-improving factory and what to do next
The self-improvingfactory builds on top of the release factory. Medin says the factory should not stop at shipping to production: it should be incorporated with production so that signals from production feed back into the factory, creating issues when users experience problems in real time.
He describes this as a recent area of research and implementation for him, which is why he says he is mostly at the release factory stage. Exactly which signals you watch and how you feed issues back is quite custom. He is clear that nothing in the release factory is scrapped: the same issue splitting, build loop, and staging environment remain, and the production feedback is added on top.
Link affiliati: possiamo ricevere una commissione sugli acquisti idonei, e non cambia i nostri dati né le classifiche. Aprono i risultati di ricerca di Amazon: prezzi e disponibilità si vedono lì.