AI software factory: five stages and one human queue

An AI software factory starts agents from triggers and ends at a person

An AI software factory is a delivery system where triggers such as a new issue or a CI failure start coding agents, and a team chooses which decisions stay human.

I ship Aldena with one. It's a pipeline in the repo's .claude/ folder, and it isn't a product you can buy from me yet. I approve the spec, then I decide only what needs me. It also wrote and merged the first version of this post without me.

Every vendor writing about factories sells a layer of one. CircleCI sells validation, Encore sells deployment, LaunchDarkly sells runtime control, and I sell the agents and the inbox. Each vendor draws the factory with its own layer in the middle.

The name is older than the agents. CircleCI points out that organizations ran software factories long before coding agents existed. Agents changed how much work shows up at the far end.

An assistant waits for you, and a factory waits for a trigger

Matt Pocock's AI Hero dictionary separates a coding assistant from a factory by who starts the session, and in a factory it's an issue, a schedule or a CI failure. Firecrawl calls the factory the system around a coding agent.

The agent can be identical in both columns. Claude Code or Codex in my terminal is an assistant, and the same binary in a sandbox, started by a webhook, is part of a factory. A second agent only helps if somebody has time to read what it opens.

Published factories share the same five stages

Firecrawl's teardown of the factories Stripe, Spotify, Shopify, Uber and Ramp published finds the same 5 stages, each with a gate that decides one thing.

1. Intake decides which work is worth starting. Sentry's Seer scores each incoming issue for actionability first.
2. Isolation keeps parallel agents from colliding. Stripe boots pre-warmed devboxes in about 10 seconds.
3. Tools set what an agent can reach. Stripe's Toolshed exposes roughly 500 internal tools over MCP.
4. Verification checks that the change is right. Spotify's LLM judge vetoes about 25% of agent sessions.
5. The merge gate says who is accountable. Faire requires two human reviews on agent-authored pull requests.

Firecrawl finds that most published factories keep a human gate on anything that isn't mechanical. Those companies have more engineers than I will ever point at this, and they still kept a person at the last step.

Review is where the queue builds

Faros's 2026 AI Engineering Report tracked 22,000 developers and, in LaunchDarkly's summary, found pull requests 51% larger and review time nearly tripled at high AI adoption.

Merges per developer rose only 16%. Those figures come through LaunchDarkly, not the report itself. CircleCI's blog cites its own 2026 State of Software Delivery, which points the same way, with feature-branch activity up 15% and throughput on main down almost 7%.

The cleanest numbers are Stephen Toub's write-up of ten months with Copilot's coding agent on Microsoft's dotnet/runtime, which Firecrawl calls the only public like-for-like dataset. Agent pull requests merged 67.9% of the time, against 87.1% for Microsoft's engineers. With a human commit added they merged 86.2% of the time, and fully autonomous ones 55.1%. Revert rates held at 0.6% against 0.8%, so what lands holds up. The waste is everything that doesn't land, and somebody has to read it to find out.

Joe McLean ran a factory for two weeks to build a music-making app and came away calling review his biggest problem. So the job, so far, leans toward reading code. I have no forecast past that, and I wrote the longer version on whether AI is replacing software developers.

My factory merged the first version of this post on its own

The marketing pipeline in Aldena's private repo wrote the first version of this post on November 9, 2026, and merged it as pull request #304 about 95 minutes after the run started.

It picked the keyword, drafted the post, ran a content audit and a review for AI tells, and marked its pull request ready. The first CI run failed on one end-to-end test. It came in when Aldena's agents were renamed for what they do, and it fails any blog link whose text ends in "role" or "roles". The draft had linked "the roles" to my post on building an agent team. In its one fix round the pipeline reworded the link, the second run went green, and the pull request merged at 13:36 UTC with no review.

Every gate passed, including the build, an audit of all 60 content pages and the full CI suite. I read the post after it merged. It had no images, six of its ten sections opened on the keyword, and "I'd" turned up nine times. The openers were the pipeline's own doing, since its check for AI tells wants each section to open on a named subject and a fact.

So the checks caught the mistakes a rule could describe. Whether anyone would want to read the thing needed a person, and the person arrived after the merge. This version waited for me as a draft.

A factory needs a queue for people too

re:cinq's autonomy table sorts changes into four classes: documentation auto-merges, application code needs a human approval, migrations need two keys and regulated work never runs unattended.

I like it because it swaps one big question about autonomy for four small ones. It leaves out the plumbing, though. Once a class stays human, something has to carry each decision to a person with its context.

In Aldena that's the approval gate and a team inbox. Aldena's own tools, such as project memory, web access and the MCP servers you add, run under an allow, ask or deny policy set per project. Claude Code and Codex agents use their own shell and file tools without asking, so that policy covers Aldena's tools, not every command they run. Asking a person a question is the one tool nobody can switch off.

A chat waiting on a person lands in the inbox, where any member can answer. When an agent stops on questions and approvals at once, they arrive together and you answer them in any order. Here the Project Setup agent has asked which channel launch announcements go to and wants three memory entries approved.

The agent resumes once, after the last answer. Answer an hour later and the run picks up with everything it had, which matters more to me than anything else on that screen.

Token price is the wrong number for a factory's cost

A cost-to-merge comparison that re:cinq cites found the cheapest coding model spending about $0.05 on generation and $2.81 to $5.73 in total, because 97% of it landed on the review gate.

Automated review costs money too. re:cinq also cites 30 days of Cloudflare's AI review gate at $1.19 per review, with engineers overriding the result 0.6% of the time. Subscriptions hit a different wall. McLean ran Anthropic's Max plan at 20x and ChatGPT Pro at 5x together, and the factory still hit limits after about 48 hours.

Budget per merged change, because a cheap model isn't cheap when its changes don't merge. Aldena's share of the bill is flat, at $20 a month for Solo, $99 for Team and $249 for Business, and your model and sandbox providers bill you directly with nothing added on top.

A dark factory is a decision per class of change

A dark factory is a codebase, or part of one, where no human reviews the output, and re:cinq's version keeps people only at intent and acceptance.

My blog ran dark for the first version of this post. A post is cheap to fix after it ships. Application code is different. Fully autonomous pull requests merged 55.1% of the time on dotnet/runtime, and a team with customers should keep a person at the merge gate until its own numbers say otherwise.

Build the factory, or buy the layers

Encore's map of the market splits it into coding agents, sandboxes such as e2b and Daytona, deployment platforms and CI/CD, and says most teams combine a coding agent with a platform.

At the open-source end, coleam00/ai-software-factory takes GitHub issues in and puts reviewed, merged pull requests out, on Archon workflows. At the packaged end, Augment Code's Cosmos sets up triggers and agents with checkpoints you choose for an engineer to review. Factory sells its coding agents to enterprises as the foundation for a software factory.

A team of five should buy most of it, and I know how that sounds coming from me. In Aldena, each agent runs on your team's Anthropic, OpenAI or OpenRouter key, or as Claude Code or Codex in the conversation's sandbox, where Claude Code can use a member's own Claude plan.

Verification is the weak row. Those agents report and test, and they don't replace a CI system you trust. The factory that ties the stages into one pipeline is still my .claude/ folder, so in Aldena you pick the agents for your team and wire them into a chart yourself.

Start with one trigger and count what reaches you

One trigger on one repository, such as a new GitHub issue, is enough for a first factory, since the first lesson is how many decisions come back to a person each week.

In Aldena, set the project's tools to ask on day one. That policy covers Aldena's tools, so the pull request is still where you check the code. On ask, the agent stops before the call. In this chat Alex asked the Project Setup agent to record three launch facts, and it waits on an approval for each.

When the same approval comes up twice, choose always allow, which writes the policy back so that question stops coming. Then watch the count. If it stops falling, a second agent only lengthens your queue, and that week is better spent on your specs and your checks.