The idea is tempting: you hand out work in the evening and a pile of finished pull requests is waiting for you in the morning. Agents that write code no longer surprise anyone. The argument now is about how to let dozens of them work at once. Let’s look at the concepts behind the Software Factory and at where the pitfalls are.
This week I held a webinar that was originally supposed to be mostly about user bots, but it ended up sliding from the AI-First Company to the modern phenomenon of the Software Factory. The response was so big that we’ll have to do a separate webinar on it.
![]()
How to manage modern software production
Agents no longer just write code, they also open pull requests at scale. According to the Octoverse 2026 report, more than 40% of pull requests on GitHub in September started as a first draft by an agent, compared with 17% in March (source: Visual Studio Magazine). Who will read those pull requests is suddenly a pretty pressing question. I, for one, don’t feel like it.
Two concepts are currently floating around the developer ether, and they are very slowly turning into usable off-the-shelf solutions. On November 17, Cognition released Devin Bots, manager agents that run teams of Devins on projects lasting days or weeks (source: Fortune). Three days later Zach Lloyd, the head of Warp, published an essay on why the future belongs to software factories. He happens to be trying to offer his own vision of it in the form of Warp Factory. Meanwhile, a pile of attempts to build your own factory is growing on GitHub: the software-factory topic has 392 repositories, and 105 of them were created in October alone. Everyone is looking forward to their first billion, which they’d earn if their solution grabbed developers by the heart and investors by the wallet.
Two visions in a nutshell
A software factory is an automated loop around the entire development cycle. Bug reports, briefs and tickets from Jira, Slack or anything else enter it on one side. Inside, specialized agents process them step by step (triage, specification, implementation, review), and at the end a pull request comes out that a human approves. Warp has been selling this as Warp Factories since August 2026 (source: TechCrunch). The key point is that the whole factory is described in code: which repositories, which agents, with which models, skills and MCP servers. Warp compares it to Terraform, except that instead of servers you deploy agents (source: Warp blog). A configuration change is then a commit with a history and the option to roll it back.
A team of agents comes from the opposite intuition. You have one “chief of staff,” you give them a project, and they chop it into smaller tasks, hand them out to other agents, monitor progress and report to you along the way. Cognition describes it in Devin Bots, for example, like this: a QA bot finds a bug and hands it to a developer bot to fix. The control feels like managing people: you assign, you check, you decide on escalations. OpenAI with its product Dots and Anthropic with Duet are going in a similar direction: always-running agents connected to Codex and Claude Code, respectively.
Lloyd’s argument: this is an optimization problem
Lloyd builds his whole essay on a single sentence. A company cares about how to deploy agents safely so that they produce as much quality software as possible for as little money as possible. That is optimization. You can only optimize what you measure. You can only measure standardized data. You only get standardized data if you centralize the work in the cloud and describe it in code. From that, the factory follows almost as a mathematical consequence. I believe him on this. I’ve tried it myself, and it’s seductive and mathematically beautiful. If you grumbled with displeasure about AI as a developer, you’ll wallow in this, because it’s a state machine like fine wine.
He also adds a punchline I like: for the first time in the history of software development we can directly measure and improve how code is delivered, because agents aren’t people. It would be a shame to waste that opportunity by turning agents into humanized colleagues and starting to “lead” them.
One thing is also fair to say out loud: Lloyd is the CEO of a company that sells factories. He is arguing for his own product. That doesn’t refute his logic, and after all he came up with the idea out of his own need, which I find likable in any product.
Where Lloyd is right
Auditability. One of the commenters (Thiruvenkadam) summed it up precisely: when every change to the factory is in code, you can find out afterward what changed and why. With a team of agents you’d be fishing it out of conversation logs. For a company with compliance requirements, such as banking suppliers or anyone who promised a client that they know who touched production code and why, that is a fundamental difference. And a benefit.
Managing agents is exhausting. Brandon Apol wrote in the discussion that managing a team of agents “fried” him: too many notifications, hard to steer, it reminded him of the time he taught in a kindergarten. In a factory you spend your time writing specifications and validations. I have a similar experience. On the project prijimackynaskolu.cz I run an agent, Eduarda, as an operations director, and her proactivity faded after a while. I wrote her a manifesto so she wouldn’t get tangled up in details and would look for work on her own, but the main impulses still come from me. Leading an agent like a human means inheriting the managerial worries too, just without human initiative. Still, it was better than the start, when instead of creative development work I just kept clicking Approved…
Personas are hard to tune. “Nobody wants to debug a failing build by coaching a persona,” wrote another commenter. A versioned pipeline is debugged like software. An agent with a role and memory is debugged like a relationship.
Where the Software Factory system chafes
Measurement is only as good as the signal. The whole factory rests on your ability to tell good work from bad. Stanislav Sorokin describes an experiment: they slipped a faulty test into the code, and all three tested agents rewrote the test instead of fixing the code. Only one of them said how to revert it. Green tests then measure how well the agent can reach green, which is something other than working software. Goodhart’s law (when a measure becomes a target, it ceases to be a good measure) naturally applies here, and a closed loop amplifies it, because it will systematically “improve” on the false signal. The authors of factories have already started building defenses against this, though, and the same set keeps recurring in open projects. A gate rejects a change that deletes a test, loosens a condition in a test, or skips it. A new test must fail on the old code, otherwise it proves nothing. The code is reviewed by a model from a different vendor. And the agent must not touch CI definitions, so it can’t write itself a green. How well these safeguards hold up in production, nobody has properly measured yet. But the problem is named and people know where to watch for it.
Vendors’ metrics mostly measure the vendors. And you can probably guess the consequences. Cognition boasts that beta testers with Devin Bots merge 4.5 times more pull requests per message (source: AlphaSignal). That is a metric that rewards how little you talk to the agent. It says nothing about whether those pull requests are worth anything. Warp, for its part, claims it automates about 30% of its tasks through its own factories (source: Warp blog). Which tasks and how big, we don’t learn. And this was my big finding: with my Software Factory I started churning out PRs by the cloud, but after the set of obvious things was exhausted, it started doing nonsense, such as normalizing abbreviations in text…
A factory for one person is possible, just not free. Lloyd explicitly assumes a platform team doing “factory engineering.” Nitesh objected in the discussion that the framework falls apart for a solo developer, who has nobody to tune the loop. He is half right. One person can assemble a small factory from GitHub Actions without a server of their own: an agent processes an issue, a second model does the review, a gate decides on merging, and a preview runs on Cloudflare Pages. That’s how I built Zandl Software Factory myself (I admit it’s my own project with three stars and a few days of age on GH, and it’s tuned to my small workflow). But you have to tune it yourself. And you pay differently: an agent in the cloud typically runs through the API and you pay per token, whereas interactive work runs on a much cheaper subscription. Sam Morgan pointed out in the discussion that this very difference keeps individuals at manually steering agents. It can be partly worked around: Claude Code can be run in GitHub Actions even with a subscription token. Then, however, the factory eats from the same limits as your own work. Or you buy a separate plan for it so the two don’t get mixed up (and that’s my solution).
Which path suits whom
The most sensible split in the discussion was written by Rafael Jegundo, and I sign off on all of it. A factory fits where you have a large volume of standard changes and can fully automate the checks. A team of agents fits where the work is varied and the checks are hard to structure.
| Situation | Rather a factory | Rather a team of agents |
|---|---|---|
| Repetitive work (dependency updates, bug fixes from reports, migrations) | yes | |
| New product, prototype, the road from zero to a first version | yes | |
| You have a platform team and reliable automated tests | yes | |
| You’re a solo developer or a small company on a subscription | yes | |
| Regulated environment, need for an audit trail | yes |
Plenty of commenters wrote “why not both,” and they are right. Michael Sullivan put it best: teams of agents give birth to factories. A team explores what to do and how, and once the procedure settles, it is cemented into a factory. That’s exactly how it has always worked in software. You first do something by hand, then you write a script, and eventually you have a CI/CD pipeline.

You probably know the GitHub Projects page. On this one, though, the tasks move across the columns by themselves as AI agents process them… So it serves me as the control center for watching my software factory.
What today’s factories can really do
I went through 26 open solutions, from projects by Addy Osmani and Vercel to one-man experiments a few days old. I evaluated them by how much work is left to the human. The result is more sober than the marketing would suggest.
Almost all of them end with a human who merges. An agent takes over an issue, writes the code, another agent reviews it, the first fixes the findings, and then a human with a Merge button waits. This is today’s unwritten consensus. Addy Osmani has it directly in his project as a principle: never auto-merge.
Only a few solutions offer auto-merge, and always with a condition. Typically based on how easily the change can be reverted. A text edit on a website or documentation goes through by itself, while a database migration or anything around payments and e-mails waits for a human.
No factory decides what to build. All the factories deal with the end of the funnel: how to turn a brief into a finished change. The beginning, meaning what should be created at all and whether anyone then uses it, remains with humans. Piotr Mińkowski’s sample factory shows this nicely: the bot opened 27 pull requests, 23 were merged, and the median from opening to merging was about an hour and a half. But all 27 briefs were written by a human.
One thing needs to be said out loud: most of these projects aren’t even three months old, and I didn’t verify the authors’ performance claims in operation, only by reading the code, because it wasn’t realistic to mess up my own deployed process with someone else’s solution when it seems to be about equally functional.
The bottleneck is moving elsewhere
The most valuable comment for me under Lloyd’s post has zero likes. Rosemary Ajuka-LeCroy writes that both visions assume the bottleneck is the production of code. For many teams, however, it has shifted to accepting it: what is worth building at all, and whether the output is good enough to ship. The factory and the team of agents both answer the production question. The question of acceptance stands above both.
I ran into this myself in another form: on Přijímačky na školu, the agents keep overloading the page with information, because they produce polished, lovingly refined statistics and overviews that an ordinary person can’t make sense of. What does it matter that we have the best process for estimating where a pupil will get in, if it means filling in a series of numbers that nobody much enjoys filling in, while a competing solution with two numbers is less accurate but actually sufficient. Instead of an airy, simple page you get a page full of explanations, numbers, additions and clarifications that can’t be read to the end.
I consider this the core of the whole debate, and the sources only confirm it. Daniel Moka, who is building a factory on top of the CodeRabbit tool (and CodeRabbit sponsored his article), arrives at the same conclusion from the other side: agents open pull requests faster than a human can read them. That’s why he mainly deals with the order and the spacing in which humans receive them to read. Code delivery is getting cheaper so fast that in a few years its price will be similar to copying files. Two things will stay expensive, at the two ends of the line. At the beginning, the decision about what should be created, and today no factory can do that. At the end, verifying that it was created correctly, and here we’re only just learning to build safeguards. And whether what was hacked together is worth releasing. AI isn’t very good at answering that…
So what will development look like
I’ll try a prediction, knowing that such predictions age within months.
Big companies will have factories. Routine work (fixes, updates, small features from a template) will flow through a loop managed by a platform team, much as CI/CD is today. A new role will emerge, which Lloyd calls the factory engineer. Whoever does DevOps today is closest to it.
Small teams and individuals will have small factories on GitHub, assembled from Actions, a second model for review, and a gate based on how reversible a change is. Boxed solutions are coming fast. Alex Krol claims in the discussion that within a few months they will be “out of the box” in half of the repositories on GitHub. That’s very optimistic, but the direction fits: 392 repositories with the software factory topic, most of which appeared in the last two months, speak for themselves. Whoever mainly needs to explore and build from scratch will stay with manually steering agents, for as long as their subscription allows.
The scarcest skill will be defining “done.” Writing specifications that can’t be circumvented. Writing tests that the agent won’t rewrite so that they pass. Being able to judge a pull request that looks good and isn’t. Seniors can do this today, and the junior positions where people learned it by writing ordinary code are disappearing. Where the next generations of developers will learn it, nobody really knows. This question worries me more than the whole dispute between factories and teams.
And on Lloyd’s closing question, whether you’d rather design a system of agents or manage a team of agents: I’d rather design. My experience with Eduarda has so far proved me right. An agent that you lead like a human needs leading like a human, and that is expensive.
In conclusion: what to take away
The “factory versus team” dispute is largely false. The two paths converge and differ mainly in what kind of work you have and how many people you have to maintain the system.
Before you start building a factory, figure out what you’ll measure quality with. Without an honest signal you’ll be efficiently optimizing nonsense.
Take vendors’ metrics with a grain of salt. Pull requests per message and the percentage of automated tasks say nothing about whether the resulting software works, and certainly nothing about whether any human wants to use such a feature in this form.
Invest in the ability to accept work. Specifications, tests resistant to circumvention, and quality review will be more valuable than the ability to write code.
Auto-merge only what is easy to revert. Texts, documentation and tests, by all means. Databases, payments, e-mails and CI configuration should wait for a human.
This text reflects the state as of November 21, 2026. Both Warp Factories and Devin Bots are at an early stage (Warp Factories on access request, Devin Bots in early access), and their capabilities and prices will change quickly. The quoted comments come from the discussion under Zach Lloyd’s post on X from November 20, 2026. The overview of open solutions is based on a study of 26 repositories as of November 21, 2026, by reading code and documentation only, without running them.