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.
Want a factory that actually ships?

We set up software factories on your stack: CI gates, review agents, QA on previews, Sentry-to-PR fixes, changelogs and SEO, with your developers and on your real tickets.

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:
  1. 1
    Signal

    Anything that says the software should change: a Linear ticket, a Sentry alert, a failing CI job, a customer email, your own idea. Most factories start with people filing tickets. The good ones also listen to production.

  2. 2
    Triage

    An agent checks if the signal is real, if it's a duplicate, and if it's clear enough to build. Our rule: if a ticket doesn't have acceptance criteria that code can check, it goes back instead of getting built. This is the slowest part of the whole factory, because most backlogs are full of tickets like "improve onboarding" and nobody volunteers to rewrite them.

  3. 3
    Spec

    Before writing code, the agent writes down what it will build and how to check it's done. A person approves it in the ticket. A misunderstanding caught here takes 2 minutes to fix. Caught in review, it takes a day.

  4. 4
    Build

    The agent builds in a fresh sandbox with no production credentials, in a fresh session. Every step gets a new agent, so context doesn't rot and one confused session doesn't poison the next. Put a budget on it: 2 CI attempts per run is enough. If the second one is still red, the run stops and leaves a report in the ticket instead of trying forever.

  5. 5
    Check

    The builder never grades its own work. CI decides if the work passes, not an agent saying "tests pass." Then a separate review agent reads the diff, and a QA agent clicks through the change on a preview deploy. Two rules worth stealing:

    • Deleting or skipping a test sends the work back automatically.
    • The agent can't edit its own rules, prompts or CI config in the same PR.
  6. 6
    Review

    This is your job. You look at what changed, not how. More on this below.

  7. 7
    Ship

    Merge, deploy, and let an agent write the changelog entry and update the help center.

  8. 8
    Watch

    Errors, logs, support tickets and analytics flow back as new signals. When something breaks, trace it to the PR that caused it. Factory does this every night. It's also how you find out whether your checks work: if the review agent approved something that later broke, you know what to fix in the factory.

    PostHog calls this self-driving: agents watch production, and when one finds a problem, another opens a PR. In October, 11% of their merged PRs started that way. A person still merges every one.

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:
  1. 1
    Week 1: make the repo ready and turn on PR review
    1. Write CLAUDE.md or AGENTS.md: how to run the app, how to test it, the patterns to follow.
    2. Get CI under 5 minutes. Add the lint rules for your top 5 conventions.
    3. Turn on preview deploys for every PR.
    4. Add the PR template from the "Standardize everything" section below.
    5. Put an AI reviewer on every PR. Tune its rules weekly from the comments you ignored.

    If a new hire can't run your app and its tests on day 1, an agent can't either. Most teams find out their factory problem is a repo problem this week.

  2. 2
    Week 2: QA and errors
    1. Add a QA agent that clicks through the changed flow on every preview and records a video.
    2. Connect Sentry and your logs. Every new error becomes a ticket, and the agent opens a fix PR with a test that reproduces the bug.
    3. You still review every PR. That's fine for now: it shows you where the agents go wrong.
  3. 3
    Week 3: changelog, help center and SEO
    1. An agent drafts a changelog entry from every merged PR and updates the help articles the change touched. You approve it.
    2. Run an SEO audit every week. The agent fixes what it finds and drafts articles from real search data.
  4. 4
    Week 4: customer requests, new features, and the numbers
    1. Turn support emails and chats into tickets with steps to reproduce. Let the agent fix the small ones.
    2. Pick one label in Linear or GitHub, like agent-ready. Tickets with that label and clear acceptance criteria go to the factory.
    3. Look at the numbers below. Expand only the jobs where agent PRs merge without changes. Kill the ones that create more review work than they save.
Skip the month of trial and error

We'll build the loop on your repo, your tracker and your monitoring, start with the safe jobs, and hand it over with the numbers that show what changed.

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.
Your repo, set up for agents in 2 weeks

Agent instructions, lint rules, fast CI, preview deploys, a PR template with screenshots and video, and AI review on every PR. We do it with your developers, so they keep it running.

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.
Build your software factory with Paralect

We set up the whole loop on your stack: agent-ready repo, CI gates, AI review, QA videos on previews, Sentry-to-PR fixes, changelogs, help center and SEO. Your team keeps it, and the numbers show what it changed.

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