AI software factories: what they are and how to build one that ships


An AI software factory is a system that takes work in (a ticket, a Sentry error, a customer email) and gives back changes that are built, checked and ready to ship. Agents write the code. Code checks it. You decide what gets built and what gets merged.
Here's everything a factory can take off your team's plate today:
The rest of this guide is how to build one. No tool does it for you out of the box: every team with a working factory did it the boring way, with tests, CI, preview deploys, a strict PR format and months of fixing what the agents got wrong.
Here's what's in it:
  • What a software factory is, and what it isn't
  • Do you need a factory, or just better engineering?
  • What a factory does all day
  • The factory loop, step by step
  • A 30-day plan
  • 5 types of factory, and which one to build
  • Standardize everything
  • Review screenshots and videos, not diffs
  • Local or remote
  • Tools to start with
  • Measure it, or it's theater
  • What a factory won't do for you

What a software factory is, and what it isn't

Earlier this year, the best teams used agents to work on the product: ship features, fix bugs. Now they build the automations that make agents work on the product for them. They stopped being product engineers and became factory engineers.
The core idea: standardize the process, not the output. A bug fix, a new feature and a copy change all go through the same steps and the same checks, no matter if a person or an agent wrote them.
It works. Kaching, a team building Shopify apps, runs 9 autonomous agents. In the last month, 77% of merged PRs in their Bundles app were opened by an agent, and merged PRs per day went from about 10 to 39.
Look at how they got there, because it's not magic:
  • Each agent owns one area and has its own Slack account. One helps support, one owns the Bundles app, one owns their AI product. People tag them in threads like a teammate.
  • They don't wait for tickets. The Bundles agent reads Sentry, logs, support chats, uninstall reasons and funnels, then opens its own issues and PRs.
  • Every PR gets the same review, human PRs too: Claude and Codex hunt bugs in the diff, a security scan runs on risky changes, and an "approach pass" asks if the code should exist at all.
  • A human merges. Agents never merge, approve or deploy to production, and their database access is read-only.
  • Rules compound. When a developer says "don't do X" once, it becomes a rule in AGENTS.md or a skill, and all 9 agents follow it.
PostHog reports similar numbers: agents write about 70% of their PRs, and people still skim at least 80% of those.
What a software factory is not:
  • Giving every engineer Claude Code or Cursor. Useful, but nothing takes a ticket from intake to merge on its own.
  • A folder of skills and MCP servers that everyone installs.
  • One agent with access to your repo. That's the build loop without the factory around it.
  • A swarm of agents in one long chat. Each agent rereads everything, and you pay for it every time.
  • A few cron jobs around cloud agents that nobody measures.
The test is simple: can a ticket go from "someone asked for this" to "a reviewed change is ready to merge" without you pushing it along? If not, you have tools, not a factory.

Do you need a factory, or just better engineering?

Half the engineers talking about software factories this autumn think they're nonsense. Read both sides before you spend a quarter building one, because for many teams the honest answer is no.
It's marketing. The most popular take came from Lauren Tan, lead engineer on the Grok bot on X, who worked on Cursor and on React at Meta before that: you don't need a software factory, you need good software engineering and to spend your tokens in the right places. She was replying to Dax Raad, who builds the open-source coding agent OpenCode and was even blunter: the companies selling you a software factory produce a shockingly tiny amount of software.
Her pyramid is the most useful picture in the whole debate. Put most of your effort at the top: a clean codebase, then static checks (lints, types, tests, CI), then verification. Prompts, skills and AGENTS.md come after. Human review is the smallest layer at the bottom. A factory built on a messy repo is a fast way to make more mess.
It's temporary. Thariq Shihipar, who worked on Claude Code at Anthropic, thinks software factories are a temporary problem, and the models will learn to build them for you. Fair. A lot of what teams hand-built in January (loops, planners, model routers to save money) is now a feature of Claude Code or no longer needed. In early 2026, people built orchestrators to send easy tasks to cheap models. With Claude Opus, you just use the best model and stop babysitting a router.
It doesn't make you faster, yet. Matt Pocock, who teaches TypeScript and AI coding to developers (Total TypeScript, AI Hero), wrote a month-by-month history of AI coding with this line for October 2026: "the promised speed gains haven't materialised, dark factory feels a long way off still." For November: "reading the code still appears essential."
It raises the floor, not the ceiling. Claire Vo, a 3-time chief product and technology officer who now helps engineering teams adopt AI, says factories are good at making average output better, which large companies need. They won't make a great engineer greater. She also warns that some of what you see online is "pure f\*ing theater and token slinging."
Our take: the name is marketing, the shift is real. The work moves from writing code to writing the rules, checks and specs that code gets written against. If you run a team of 5 and your Claude Max subscriptions already ship everything you need, you don't need a factory. If you run 30 engineers and every one of them uses agents differently, you need the process a factory forces on you, whatever you call it.

What a factory does all day

Forget "it builds the whole app." These are the jobs factories actually run in production today, in the order we set them up:
Job
What starts it
What the agent does
How you check it
PR review
Every PR
Comments on bugs, security holes, broken conventions
You accept or ignore the comments
QA
Every preview deploy
Clicks through the changed flows with Playwright, records a video
You watch the video
Errors and logs
A new error in Sentry, a spike in Better Stack or Axiom
Groups duplicates, finds the cause, opens a fix PR with a test that reproduces the bug
The error stops coming
Changelog and help center
A merged PR or a release
Writes the changelog entry with screenshots, updates the help articles the change touched
Read it, 2 minutes
SEO
A weekly audit, Search Console data
Fixes broken links, meta tags, slow pages, writes articles from real search data
The audit passes, pages get indexed
Customer requests
A support email, an Intercom chat, a Slack message
Turns it into a ticket with steps to reproduce, fixes small ones, drafts the reply
The customer confirms
New features
A ticket moved to "Ready" in Linear or GitHub
Writes a plan, builds it, opens a PR
You review the result on staging
Start at the top. PR review, QA and error fixes save your team hours from the first week, and a bad review comment or a failed QA video costs nothing. New features are last, because a misunderstanding there costs the most and no test catches "this isn't what I meant."

The factory loop, step by step

Every factory that works looks roughly the same. Factory's own setup, the ones other teams have published and the open-source ones all land on this loop:

A 30-day plan

Don't start by building a "software factory." Build a bug factory, a security factory or a UI polish factory. Small scope, easy to measure. Here's the order we recommend:

5 types of factory, and which one to build

There are 5 types of factory, and they explain why some people say factories are a scam and others merge thousands of agent PRs. It depends on one question: can a test prove the work is right?
Type
How it works
Use it for
Dark factory
Takes a loose request, plans, builds, reviews and merges to production with no human
Prototypes and throwaway proofs of concept. Nothing with users.
Fleet factory
Same automation, but only for work with a clear, testable goal
Migrations, dependency upgrades, refactors, cleanups
PR factory
Agents build each ticket, you review every PR
Getting started, or code where mistakes are expensive
Release factory
You plan 10 to 20 tickets together, agents build them in parallel, you review the batch on staging
Most product work, once your checks are good
Self-improving factory
A release factory that also turns production errors and analytics into new tickets
When you trust the loop and want it to fix what users hit
The dark factory fails for a reason no model upgrade will fix: you won't describe what you want perfectly every time, and with no human in the loop, every gap in your request ships to production. Public dark factory experiments this year all ended the same way: the agents did their job, and the app still wasn't what the author wanted. Even open-source factories now say it in the README: "This is not a dark factory." People plan the release and test it on staging.
The fleet factory is the dark factory that works, because the goal can't be misunderstood. "Upgrade the dependency and keep all tests green" is checkable. "Make onboarding better" isn't. The biggest wins you've read about are all fleet work:
Nobody at Spotify lets Honk design features. That's the point.
Our recommendation: start with a PR factory, move to a release factory. Reviewing every PR is slow, but it shows you where the agents go wrong, and that's what you need to learn before you stop reading every change. Then batch the work, review it on staging, and turn the dial per project: review everything on payments, nothing on dependency bumps.

Standardize everything

The factories that work are boring. Every PR looks the same, every task follows the same steps, every repo is set up the same way. That's what lets an agent do the work and lets you check it in 2 minutes.
One way to write code. Agents copy whatever they find. If your repo has 3 ways to fetch data, you'll get a 4th. Pick one pattern per thing, write it in CLAUDE.md or AGENTS.md, and enforce it with lint rules, not prose. A lint rule the agent can't skip beats a paragraph it can ignore.
Fast, strict checks. Types, lints, unit tests, end-to-end tests on the main flows, preview deploys on every PR. If CI takes 25 minutes, your factory does 2 attempts an hour. Get it under 5.
One PR format. Every agent PR opens with the same template, so you know where to look:

Loading editor...

## What changed
One sentence a customer would understand.

## Why
Link to the ticket, the Sentry issue or the customer request.

## Changed surfaces
Write "None" under a heading when nothing changed there.

### Database
| Table | Change |
| --- | --- |
| `invoices` | new column `paid_at`, nullable |

### Migrations
| Migration | Does | Data | Risk |
| --- | --- | --- | --- |
| `20261117_add_paid_at` | adds `paid_at` | backfills from payments | low, runs in under a minute |

### Screens
| Screen | Change |
| --- | --- |
| `/app/invoices` | new "Paid on" column, filter by paid date |

### Customer communication
| Channel | Change |
| --- | --- |
| Email | "Invoice paid" email now shows the payment date |
| Web notification | none |

## Before / after
Screenshots of every changed screen, desktop and mobile.

## Video
30-60 seconds of the agent clicking through the flow on the preview.

## How it was checked
- [x] CI green on first or second run
- [x] Review agent: 0 blocking comments
- [x] QA agent: flow recorded, no console errors

## Risk
Low / medium / high, and what to look at if it's not low.
The changed surfaces section is the one that saves you. A diff hides a new database column on line 400 of file 12. A table at the top shows it in 1 second, together with the migration that locks a busy table, the screen that changed and the email that 10,000 customers will get tomorrow. That's where things go wrong in production, so that's what you read first. Here's what it looks like on a real PR from our own factory:
The same steps for every task. Plan, build, check, review, ship. When a task skips a step, the factory sends it back. For bigger teams, this is half the value: a factory enforces a process that would be hard and annoying to enforce by hand.

Review screenshots and videos, not diffs

When agents write 39 PRs a day, you can't read 39 diffs. And you shouldn't try: a clean diff can still ship the wrong feature. What you need to know is does it do what I asked, and the fastest way to see that is to look at it.
  • Screenshots of every changed screen, before and after. You catch a broken layout in 1 second.
  • A short video of the flow on the preview deploy. You see the empty state, the loading state and the error message nobody thought about.
  • A plain-language summary at the top of the PR, not 3 paragraphs of "I updated the component to use the new hook."
  • The changed surfaces: database, migrations, screens and customer emails, so you see what a change touches before you open the diff.
  • The risk score, so you know which 3 PRs out of 39 deserve a real read.
A cheap trick: have the agent build a small HTML page for each PR with the screenshots, the video and the test results side by side, and review that.
Then read the code where it matters. The hot take that "nobody reads code anymore" is wrong for anything touching auth, payments, data migrations or permissions. The No AI Slop Manifesto, written at this month's AI Engineer Code Summit, puts it well: "a swarm of agents can produce more work in a single day than a person can review in our lifetime," and "agent reviews, linters, and verifiers are useful but not sufficient." Read the risky code. Skim the rest. Let a video prove a button moved.

Local or remote

There are 2 ways to run a factory, and most teams end up with both.
Local factory
Remote factory
Runs on
Your laptop, in an app
A server or the cloud
Runs when
Your laptop is open
Always, triggered by webhooks and schedules
Pays with
Your Claude or ChatGPT subscription
API usage, Team seats, or a subscription on a VPS
Good for
Solo founders and small teams, doing your own tickets faster
Teams, work that starts without a person (errors, PRs, releases)
Examples
Claude and Codex desktop apps, T3 Code, Conductor
Claude Code scheduled tasks and GitHub Actions, Capy, Factory, a VPS
A real factory is remote. The point is that work starts without you: Sentry fires at 3am, an agent triages it, and a fix PR is waiting when you wake up. That can't happen on a closed laptop.
Most people still run local, and for good reason. A Claude or ChatGPT subscription at $100-200 a month buys far more work than the same money spent on the API. Anthropic and OpenAI know it, so they keep adding scheduled tasks and automations to their own apps. Claude Code's scheduled tasks now run in Anthropic's cloud on your subscription, triggered by a schedule, an API call or a GitHub event. Codex can run tasks on a schedule too, though local runs need your computer on and the app open. It's convenient, and it's built to keep you inside their app instead of your own pipeline.
The middle path: a VPS with a subscription. Rent a small server, install Claude Code, Codex or Hermes Agent, log in with your subscription and run jobs with cron or a small webhook listener. It's a remote factory at subscription prices. Kaching runs all 9 of its agents on Hermes on one VPS, with Claude Code writing the code. The bill: about $2,500 a month for 20 Claude Team seats, plus $100 for the server.
Read the terms before you copy it. Anthropic's legal page says plan limits "assume ordinary, individual usage," and third-party tools may not route requests through Pro, Max or Ultra credentials on behalf of their users. Signing in to the official Claude Code with your own subscription is fine. One login shared by a whole team's bots is a grey area, and Anthropic can enforce it without notice. You also own the uptime, the secrets and the security of that box. For a solo founder or a team of 5, it's often the best deal there is. For 30 engineers, pay for the API or Team seats and sleep well.
Here's our test: if you stop paying the vendor tomorrow, does the factory keep running? If the whole thing lives inside one vendor's app, you're renting the production line.

Tools to start with

You don't need to build a factory from scratch to try the idea. Start with an agentic IDE that runs many agents in parallel, and you'll feel where the process breaks before you write any pipeline code. Our full comparison is in Top agentic IDEs.
Capy is the closest to a remote factory out of the box. T3 Code is the best free start.
Then add the remote pieces: an agent in CI, a PR reviewer, browser tests for QA and production signals. If your team is new to agents, roll out Claude Code first.

Measure it, or it's theater

A factory isn't a factory unless you can measure, test and improve each part of it. Warp, the terminal company, counts every time a person has to step in as a failure the factory should learn from, and measuring each step is how they cut their cost per PR by about 63%. Without numbers, you have a token bill and a feeling.
Metric
What it tells you
Regret-free merge rate
Share of agent PRs that merged and didn't need a revert or a follow-up fix. The main number: climb it until you can automerge.
Share of merged PRs by agents
Kaching is at 77%, PostHog at about 70%.
Merged PRs per day
Kaching went from 10 to 39. If this doesn't move, the factory isn't working. Count merges, not PRs opened.
Bugs traced to agent PRs
Compare with bugs from human PRs. When agents break things less often, give them more autonomy.
Cost per merged PR
Tokens and compute divided by what merged. Not per run, per merge.
Time from signal to merge
How long an error, a request or a ticket waits before it's fixed.
Think of self-driving cars: nobody flipped a switch. They got to drive once they crashed less than human drivers. Let agent PRs automerge only when you can show they break things less often than yours.
One more rule: report these by team, never as a ranking of developers. The moment people get ranked on agent output, you get token slinging.

What a factory won't do for you

  • Decide what to build. Product discovery, talking to customers and choosing the next bet stay with people.
  • Design your architecture. New systems, big refactors, performance work and new domains need someone who holds the whole picture in their head.
  • Fix unclear tickets. A factory multiplies whatever goes into it. Vague tickets turn into wrong features, faster.
  • Save a bad codebase. Agents copy what they see. Clean it up first, or the factory makes more of it.
  • Run without an owner. Someone has to tune the review rules, fix the flaky tests and read the reports every week. That's the factory engineer's job, and it's a real job.
The teams getting results aren't the ones with the fanciest pipeline. They're the ones who did the dull work: strict checks, a standard PR, clear tickets, and a weekly look at what broke. The agents were the easy part.

Sources

Ship faster than
your competition

Focus on customers and sales while we handle product delivery. Hire a dedicated AI maker or a whole product team.

Launch new products
Fix your delivery
Hit fundraising milestones
[Analytics Chart]
Wireframe v0.1
User
Sarah Chen CEO, Founder
$127k
MRR
2,847
Customers
+23%
Growth
Sales Performance
Latest Deal
Customer
Enterprise plan closed
Acme Corp · $12k/mo
© 2026 Paralect, Inc 651 N Broad St, Suite 206, Middletown, 19709, Delaware, United States