Software factories: how AI agents ship code start to finish

Stripe's coding agents, which the team calls Minions, merge more than 1,000 pull requests a week. An engineer tags the bot in Slack, a sandbox spins up in about 10 seconds, and the agent writes the change end to end.

"Though humans review the code, minions write it from start to finish," says Stripe's Alistair Gray, a software engineer on their Leverage team.

At Anthropic, Claude wrote about 80% of the code merged into the company's codebase, as of May 2026. In Q2, the typical Anthropic engineer merged 8x as much code per day as they did in 2024.

That volume is landing on engineering leaders everywhere. Agents write code faster than the rest of the pipeline can absorb it, and the backpressure hits every stage downstream: review queues, test suites, CI capacity, deploy cadence, and the maintenance load on code nobody has read closely.

A software factory is an attempt to run the whole line. It coordinates agents across coding, testing, review, and deployment, and the goal is a repeatable path from ticket to production.

What is a software factory?

A software factory is a system that coordinates AI agents to write, test, review, and deploy code in an end-to-end repeatable workflow.

PostHog's newsletter lays out the five-step pipeline most factories follow today. Humans decide what to build and put it in a ticketing system. Agents pull tickets, build and test PRs, and submit them for CI and review. Approved PRs deploy through CD. Rejected PRs go back to an agent for another pass. Production usage and feedback inform what gets built next.

Right now there are three types of software factories:

• Light factory – agents write most of the code, and a human reads it before it ships. This is where nearly every company in production sits today.
• Dark factory – in Addy Osmani's definition, "code ships that no human has read, verified only by other machines." StrongDM is the public example: 3 engineers, code that must not be written or reviewed by humans, and a floor of $1,000 a day in tokens per engineer.
• Twilight factory – Ethan Mollick's newest term, coined in August 2026. "Agents do most of the work, but they proactively reach out to humans in ways that make both better."

Ramp, Cursor, and Uber all run autonomous background agents in production without calling them factories. The label matters less than the design decision behind it: where do humans sit in the line?

Who's running software factories in production

OpenAI offers another view of where this is heading. In a September 15 interview with The Pragmatic Engineer, its engineering leaders described a pipeline where areas of the codebase can opt into automatic approval of low-risk PRs. Higher-risk changes can require additional agent reviews or human review.

The category now has funded vendors attached to it. Factory raised $200M at a $5B valuation in September, naming Nvidia, Royal Bank of Canada, Adobe, and T-Mobile as customers.

Cursor CEO Michael Truell put the shift plainly: "Cursor is no longer primarily about writing code. It is about helping developers build the factory that creates their software."

How a software factory works: loops, harnesses, and review agents

Addy Osmani's three-layer explanation is useful. A loop is an agent repeatedly gathering context, acting, and checking results. A harness supplies its environment, tools, permissions, and stopping conditions. A factory coordinates those loops across a queue of work.

Six components show up in every factory that works:

• Automations – schedule recurring work like issue triage, CI summaries, and reviewer assignment. Sentry's routine assigns reviewers every 4 hours.
• Worktrees – isolate parallel agents. A study of 33,596 agent PRs found conflicts in 19.8% of same-agent pairs and 41.7% of pairs from different agents.
• Skills – store conventions, build steps, and organizational context in SKILL.md files. Uber runs 3,600+ agent skills at 30,000 executions a day
• Connectors and MCP – let agents open PRs, link tickets, and trigger notifications. Stripe's Toolshed exposes ~500 internal tools over MCP.
• Sub-agents – separate makers from checkers. Cloudflare runs a coordinator that dispatches specialist reviewers.
• Memory – track completed work and next steps across runs.

Deployment options are expanding too. Cursor's September 2 self-hosted machines release lets agent tools execute inside a company's own infrastructure. That gives teams more control over the execution environment; model access and data handling still need separate evaluation.

Our guide to loop engineering covers the underlying building blocks in more detail.

Why software factories fail

HumanLayer ran a lights-off factory starting in July 2025. Agents wrote, reviewed, and deployed with no human reading the code. It lasted a few months before an outage sent the team on weeks of archaeology through code nobody had ever read. CEO Dex Horthy's post-mortem, Why Software Factories Fail, went viral in July.

His argument is that passing tests provides immediate feedback, while the cost of poor architecture emerges over months. An agent can complete each ticket and still make the overall system harder to maintain.

Faros's 2026 research raises a related concern. Across telemetry from 22,000 developers, the incidents-to-PR ratio rose 242.7% between each organization’s lowest and highest AI adoption periods, while bugs per developer rose 54%. These are observational findings from Faros customers, not proof that AI caused every increase or that a particular factory design will fail.

Osmani calls the human side comprehension debt. In an Anthropic study of 52 engineers, the group using AI scored 17 points lower on a quiz about code they had just written, with the biggest drop in debugging.

Then there's cost. Multi-agent systems use about 15x the tokens of a single chat. Simon Willison's reaction to StrongDM's $20,000 a month per engineer: "far less interesting to me."

Where software factories are landing: humans up front, agents in the middle

Horthy's fix is to put human judgment back at four points: product review, system architecture, program design, and vertical slices reviewed as they land. "30 minutes of planning saves hours of review." He claims 2–3x throughput from that setup, against a 10–100x dark-factory promise that collapses under production load.

Mollick's twilight factory gets to the same place from the other direction. A facilitator agent pulls humans in on four triggers: approval (spending money, contacting outsiders, touching sensitive data), expertise the model lacks, variance when agents converge on the same idea, and interest. "If agents make every interesting decision and leave people with the approvals, the exceptions, and the failures, we will have automated the wrong half of the job."

PostHog pushes back on both. The missing piece is context. Agents make better design choices when they can see what a product engineer sees: usage data, complaints, incidents. At PostHog, 63% of changed lines land in files that already exist and "fix" is the largest commit type at 40%. Give agents production signals and "turning off the lights might not be so crazy after all."

Cloudflare's 0.6% override rate is what this looks like when it works. Seven agents review everything. Humans only overruled them 288 times in 48,000 merges.

Where to start with your software factory

Choose one workflow with clear acceptance criteria and a manageable failure cost. Review assistance, a bounded migration, or fixes for a known class of bugs are reasonable starting points. Keep a named engineer responsible for the outcome.

Before increasing volume, establish four things:

1. A baseline. Track time to merge, review effort, rework, and production failures so you can tell whether the workflow improves delivery.
2. A release gate. Decide which checks must pass, which changes need human approval, and what happens when an agent cannot finish.
3. Operational limits. Set tool permissions, retry and spending limits, and a way to stop the agent or roll back its changes.
4. Cost per useful outcome. Include failed runs, reviews, and corrections. Track what it costs to land an accepted change and whether quality holds.

Uber's factory operating model pairs cost per merged PR, review, or resolved alert with quality measures such as revert rate. That gives leaders a more useful basis for expansion than token consumption or generated code volume alone.

Codingscape helps teams ship their AI-generated code faster, starting with the CI/CD pipeline, review process, and production controls that determine what reaches users.