---
title: How to Set Up a Release Factory for Coding Agents
url: "https://goremy.ai/blog/articles/how-to-build-release-factory-coding-agents"
author: Luis Chavez-Mattos
editor: Luis Chavez-Mattos
editor_title: Director, Product
published: "2026-11-18T20:40:10.069Z"
updated: "2026-11-18T20:40:10.069Z"
topic: Coding and DevOps with AI
description: "Step-by-step release factory workflow: bundle 10-20 tickets into a work order, run parallel build loops, and review one merge PR plus staging."
---

# How to Set Up a Release Factory for Coding Agents

> Step-by-step release factory workflow: bundle 10-20 tickets into a work order, run parallel build loops, and review one merge PR plus staging.

Edited by Luis Chavez-Mattos, Director, Product · Published 2026-11-18

## What is a release factory for coding agents?

A release factory is a way of running coding agents on a batch of tickets instead of one ticket at a time. You plan the whole release with the agent up front, split it into a set of issues, let agents build them in parallel, and then review the result together in a staging environment. You sign off once, on the release, instead of reviewing every pull request (PR) separately. You stay in the loop at the two points that matter most: planning and validation.

## TL;DR

- A release factory moves your effort to the two ends of the process: **heavy planning up front** and **batch validation at the end**, with agents handling the middle.
- You bundle a **work order of roughly 10 to 20 tickets**, map their dependencies, and let agents build independent tickets in parallel.
- Each step (plan, build, review) should run in a **fresh agent session**, and the reviewer should never be the agent that wrote the code.
- Individual tickets merge into a release branch, so you review **one merge PR plus a staging deployment** rather than a pile of small PRs.
- Nothing ships to production until a human signs off on staging.
- It is not waterfall, because releases are small and short. It is a middle path between reviewing every PR and trusting the agent with everything.
- If you are new to this, **start with a single-ticket loop** and widen it into a release once the build loop works.

## How is a release factory different from other AI software factories?

"Software factory" is a loose term, and the types differ mainly in how much a human reviews. Five common types came up in a recent breakdown from a creator who builds these systems:

| Type | What it does | Human review |
|---|---|---|
| Dark factory | Takes a loosely structured request, plans, builds, reviews, and merges straight to production | None |
| Fleet factory | A dark factory aimed only at work with a clear goal and a testable outcome, such as migrations and maintenance | Little, because tests can prove the work |
| PR factory | Runs the build loop per issue, and you review every PR | Every pull request |
| Release factory | Batches issues, builds in parallel, deploys to staging | One review of the batch, plus sign-off |
| Self-improving factory | Not covered here | Not covered here |

The reason not to skip the human is simple. You will not communicate your intent perfectly every time. When you get it wrong, a dark factory ships the mistake. The creator ran a public dark factory experiment, with separate agents reviewing and auto-merging to production. It worked reasonably well, but small problems piled up because he did not know exactly what he wanted at the start. The agents did fine. The instructions were the weak point.

Fleet factories avoid that problem by picking work where intent is easy to state and tests can prove success. Spotify's system, Honk, has merged more than 2.5 million automated maintenance PRs, and Airbnb migrated 3,500 test files in six weeks. Most product work is not that clean. It involves judgment calls, and that is where the release factory fits.

The PR factory is the safest option, but you remain the bottleneck. You automate the plan, build and iterate sessions, but you still read every PR. The release factory keeps most of the safety and removes most of the repeated reviewing.

## How do you set up a release factory, step by step?

Here is the process, from idea to production.

1. **Write the PRD with the agent.** A PRD (product requirements document) says what the release should do and why. Spend real time here. The agent can ask you questions, challenge gaps, and propose scope, but you decide what is in and out.
2. **Turn the PRD into a work order.** The work order is the list of tickets for this release, usually 10 to 20 of them. Each ticket should be small enough for one agent to finish and check.
3. **Create issues and map dependencies.** Put each ticket into your tracker (GitHub issues, Jira, whatever you use). Note which tickets must wait for others. Agents are good at helping with this mapping.
4. **Run build loops in parallel.** The factory works out by itself which tickets it can handle in parallel, such as those with no unfinished dependencies, and each of those starts its own build loop. As blockers merge, the next tickets start.
5. **Review each build with a separate agent.** A different session checks the work against the ticket before it merges into the release branch.
6. **Deploy the release branch to staging.** Everything that passed review lands in one place you can click through.
7. **Review and sign off.** You read the single merge PR, test staging, send fixes back if needed, and approve the release to production.

## What goes into a good work order?

The work order is where your planning pays off. A vague ticket produces a vague build, and 15 vague tickets produce 15 problems at once. Give each ticket the same shape.

```
Ticket: [short title]
Goal: [one or two sentences on what changes for the user]
Acceptance criteria:
- [observable, checkable statement]
- [observable, checkable statement]
Out of scope: [what the agent should not touch]
Depends on: [ticket numbers, or "none"]
How to verify: [test to run, page to open, or behavior to check]
```

The "How to verify" line matters most. The agent needs a way to know it is done, and the reviewer needs a way to check. If you cannot write that line, the ticket is not ready.

To get the dependency map, you can paste your tickets into an agent session with a prompt like this:

```
Here is the work order for this release. For each ticket, list which other
tickets must be merged before it can start. Flag any two tickets likely to edit
the same files. Then group the tickets into waves, where every ticket in a wave
can be built in parallel.
```

The "same files" flag is worth keeping. Parallel agents that edit the same code create merge conflicts, and it is cheaper to sequence those tickets than to untangle them later.

## Why use fresh sessions and separate reviewers?

Agents work from their context, meaning everything in the current conversation. A long session fills with old attempts, dead ends, and assumptions. Starting a fresh session for each step (plan, build, review) gives the agent a clean slate and only the inputs it needs: the ticket, the spec, and the code.

Separation matters even more for review. An agent that just wrote code tends to agree with its own reasoning. A reviewer in a new session sees the ticket and the diff with no memory of why a shortcut seemed fine. Give it the acceptance criteria and ask it to find where the code fails them, not to confirm that it works.

A simple review prompt:

```
You are reviewing a change for this ticket: [ticket text].
Do not assume the code is correct. Compare the diff to each acceptance
criterion and list any that are unmet, untested, or only partly met.
Also note anything changed that the ticket did not ask for.
```

If the reviewer finds problems, the ticket goes back to a fresh build session with the findings attached. Cap the number of rounds so a stuck ticket gets flagged for you instead of looping forever.

## How do you review a release without reading every PR?

You review at the release level. Individual ticket branches merge into a release branch after the agent review passes. That gives you two things to look at:

- **One merge PR** showing the whole release against your main branch. Skim it for scope: does it contain only what the work order asked for?
- **A staging environment** where you use the product. This is where you catch the "that is not what I meant" problems, the ones that tests and code review miss.

Walk through each ticket's "How to verify" line on staging, then try a few things that are not on the list. Feedback goes back to the agents as new tickets or fixes. When staging looks right, you approve the release.

## Is a release factory just waterfall?

No. This is a common misconception. The release is small, around 10 to 20 tickets, not a months-long plan. You plan, build, and validate in a short cycle, then do it again. The up-front planning is also not a frozen contract. It is a way to catch misunderstandings before agents build on them.

## Is a release factory worth it?

It depends on where you are.

- **If you are new to agent workflows,** start with a PR factory on single tickets. You learn how the build loop behaves while reviewing everything. Widen to a release once the loop is reliable.
- **If your work is migrations or maintenance with strong tests,** a fleet-style setup may need even less review.
- **If you build product features with real judgment calls,** the release factory is the practical middle. You gain scale over reviewing every PR without trusting an agent to ship unreviewed to production.

## What this means for you

If you are a developer, your job shifts toward writing clear tickets, spotting dependency problems, and judging a finished release. Those skills now set your output limit more than typing speed does.

If you are a product manager, analyst, or operations lead who works with engineers, the work order is your territory. A strong PRD and tickets with clear acceptance criteria are the inputs that decide whether a release works. You can start practicing now: take one feature, write it up in the ticket template above, and ask an agent to find the gaps.

If you manage a team, pick one low-risk release and run it end to end. Note where the agents stalled and where staging review caught problems. That tells you whether to tighten your tickets or your review.

## Can you build a release tracker instead of using spreadsheets?

A release factory creates a lot of small state to track: which tickets exist, what each depends on, which are in build or review, and whether staging is signed off. Many teams end up with a spreadsheet or another subscription for this. With [Remy](https://goremy.ai), you can describe that tool in plain English (a work order board with dependency fields, a status column per ticket, a staging checklist, and a sign-off button restricted to approvers) and get a deployed full-stack app with a database and login. It is your own app, so you can adjust fields as your process changes.

## Frequently Asked Questions

### How many tickets should a release contain?

A range of 10 to 20 tickets works well for a work order. It is large enough to save you review time and small enough that staging review stays manageable. If you struggle to verify a release on staging, make the next one smaller.

### Do I need a different agent tool for each step?

No. What matters is that each step runs in its own fresh session with clear inputs. You can use the same coding agent for planning, building, and reviewing, as long as the reviewer starts clean and does not inherit the builder's context.

### What if two tickets conflict with each other?

Catch it during dependency mapping by flagging tickets that touch the same files, then run them in sequence instead of in parallel. If a conflict still appears at merge time, treat the fix as its own ticket with a fresh session.

### Why not let the agents merge straight to production?

Because mistakes in communicating intent will happen, and no model quality fixes that. Staging review gives a human the chance to catch "built correctly, but not what I wanted" before users see it.

### Where should I start if I have never run a factory?

Start with one ticket and a three-step loop: plan, build, review, each in a fresh session, and review the PR yourself. Once that loop is dependable, add more tickets, dependency mapping, and a staging environment.
