# What is a software factory process?

A software factory process is the fixed sequence of stages that every change passes through, from a written goal to a checked and shipped result.

Last updated November 19, 2026, 9 min read

## Learning objectives

After reading this article you will be able to:

-   Define a software factory process
-   Describe the stages each phase passes
-   Explain why the process decides the result

## Related content

-   [What is a software factory?](https://specstory.com/learning/software-factories/software-factory)
-   [What is verification in a software factory?](https://specstory.com/learning/software-factories/software-factory-verification)
-   [What is a software factory operator?](https://specstory.com/learning/software-factories/software-factory-operator)
-   [How to build a software factory](https://specstory.com/learning/software-factories/building-a-software-factory)

## What is a software factory process?

A software factory process is the fixed order of stages that each change passes, from a written goal to a shipped result. Every change takes the same route. The process says which agent works at each stage, what that agent may not do, and where a person decides.

In a [software factory](https://specstory.com/learning/software-factories/software-factory), agents do most of the work, so the process holds what a team's habits used to hold. This section calls one unit of work a phase. A phase is one change that moves through the factory, from a written goal to one commit.

The factory starts an agent workflow for each phase. An agent workflow is a script that runs a fixed sequence of agents, each with one job. Claude Code's documentation describes [a dynamic workflow](https://code.claude.com/docs/en/workflows) as a script that orchestrates many [subagents](https://specstory.com/learning/glossary#subagent) at once.

## How does a software factory process work?

In [one operator's published log](https://www.meditationsontech.com/p/what-its-like-to-operate-a-software), a phase passes four stages, which are decide, build, check, and ship. The steps inside those stages run in this order:

1.  An [operator](https://specstory.com/learning/software-factories/software-factory-operator) asks for a change in a sentence or two.
2.  A coordinating agent writes the goal, with its rules and open decisions, and the operator says go.
3.  A spec agent splits the goal into parts that builders can work on side by side.
4.  Builder agents write the code, and an integrator agent merges it and runs every test.
5.  Checker agents run the software at the [check stage](https://specstory.com/learning/software-factories/software-factory-verification) and report pass or needs work.
6.  A fixer agent fixes each finding, and a recheck agent repeats the failed steps.
7.  One agent commits the phase, a release script deploys it, and the operator tries it.

[An earlier post](https://www.meditationsontech.com/p/building-a-software-factory-aint) by the same operator cuts the work more finely, into six stages. They are spec, build, verify, fix, reverify, and commit. Three properties turn that sequence into a process:

-   **The order is fixed.** A script runs the stages, so no agent can skip one.
-   **Each stage has a limit.** In that earlier factory, the verify stage never passes work by reading the code, and only one agent commits.
-   **The rules live in files.** A rule in the rules file binds every later agent. A rule said once in a chat is gone when the session ends.

The guide on how to [build a software factory](https://specstory.com/learning/software-factories/building-a-software-factory) turns these stages into files and scripts.

## What is an example of a software factory process?

Here is an illustrative example. Acme Co. sells furniture online. An operator at Acme asks the factory to "Let customers edit their delivery address during checkout." The phase runs in five steps:

1.  The coordinating agent writes a goal with two [acceptance criteria](https://specstory.com/learning/ai-coding/acceptance-criteria). The address can change during checkout, and the cart stays the same.
2.  The operator reads the goal and says go.
3.  Two builder agents change the checkout code, and the integrator agent runs every test.
4.  A checker agent uses the store and reports needs work. The address saved, but the cart emptied.
5.  A fixer agent corrects the code, the recheck passes, and one agent commits the phase.

The process caught the failure because the check came after the build in a fixed order. This example is simplified. A real factory would also run a release step after the commit, and keep a record of what the operator tried afterward.

## Why does the process decide more than the tools?

The tools in a factory change often. A team can swap one coding agent for another, and the models change from one release to the next. The process stays, and three parts of it decide what a factory ships:

-   **The goal decides what gets built.** A vague goal produces a change that fits no need. Written goals are the subject of [spec-driven development](https://specstory.com/learning/ai-coding/spec-driven-development).
-   **The check decides what counts as finished.** A factory with strong builders and no check stage ships whatever the builders report. A [definition of done](https://specstory.com/learning/verification/definition-of-done-for-coding-agents) states that agreement in advance.
-   **The rules decide what repeats.** A mistake that becomes a written rule is less likely to happen the same way twice.

The volume of work makes the process the main control. In the log cited above, a software factory deployed to production 72 times in 31 days. Its median change touched 4,578 lines of code across 47 files. The operator does not read changes of that size at that pace, so confidence in each change has to come from the process that produced it.

Car factories reached the same result decades earlier. A post on [Toyota's production system](https://specstory.com/blog/toyota-manufactures-learning) follows how the system of production decided more than the machines did.

## What are the limits of a software factory process?

A factory process has three limits:

-   **A process repeats its gaps.** A stage that the process lacks is missing from every phase, so one design mistake affects every change.
-   **A fixed order costs time.** A small fix waits for the same stages as a large feature.
-   **A process fits one product.** Rules that suit one codebase can be wrong for the next. A team that copies a process still has to write its own rules and its own checks.

## How is a factory process different from a traditional SDLC?

A traditional software development life cycle (SDLC) can be described with the same four stages. The difference is who works at each stage. In a traditional SDLC, a person does almost every step, and the working limits are set for people.

[Google's engineering practices guide](https://google.github.io/eng-practices/review/developer/small-cls.html) says 100 lines is usually a reasonable size for a change and 1,000 lines is usually too large, and leaves the call to the reviewer. Limits on [pull request size](https://specstory.com/learning/code-review/pull-request-size) exist because a person has to read each change.

[Google's guide](https://google.github.io/eng-practices/review/reviewer/speed.html) also says one business day is the maximum time it should take to respond to a code review request. A factory process moves people out of that waiting line. The operator asks, says go, and tries what comes out.

Diagram: The same four stages, before coding agents and with a software factory

Both rows are redrawn from one operator's post and have the same four stages. The factory moves the person to three places: asking, saying go, and trying what comes out. The upper times are that operator's estimates, and the lower times were measured in one phase.

The older steps do not disappear. The build and test steps of [continuous integration](https://specstory.com/learning/ci-cd/continuous-integration) run inside the build and ship stages. The manual work of [QA testing](https://specstory.com/learning/testing/qa-testing) moves to checker agents. Whether the last stage deploys without a person is the question that [continuous deployment](https://specstory.com/learning/ci-cd/ci-vs-continuous-delivery-vs-deployment) answers.

One loss needs a plan. [Code review](https://specstory.com/learning/code-review/code-review) spread knowledge of the code across a team, and a factory process has no stage that does this by default.

## How can a team check what the process ships?

Give the process one stage that runs the finished software, and let no phase skip it. A check from outside the factory's own agents does not share their context. The guide to running [several agents at once](https://docs.specstory.com/runstory/workflows/parallel-agents) shows such a check on each agent's branch.

RunStory independently runs the software against your change and returns evidence to the coding agent. After your agent makes the change, RunStory repeats the failing workflow to check that the problem is resolved. The operator cited on this page runs the factory that builds RunStory. Your team keeps the final release decision.

[Join the RunStory alpha →](https://specstory.com/runstory#alpha)

## FAQs

### What is a phase in a software factory?

A phase is one change that moves through a software factory, from a written goal to one commit. Each phase takes the same route through the stages, and a phase that passes its check skips the fix. The factory starts one agent workflow for each phase.

### What is an agent workflow in a software factory?

An agent workflow is a script that runs a fixed sequence of agents, each with one job. A software factory starts one workflow for each phase. The script holds the order of the stages, so no agent can skip one.

### Which stage decides whether a change ships?

The check stage decides whether a change moves on. A checker agent runs the software and reports pass or needs work. A change that needs work goes to a fixer agent and a recheck before any agent commits it.

### Where do people sit in a software factory process?

People sit at the start and the end of the process in the factory this page follows. An operator asks for the change and approves the written goal. After the release, the operator tries the result and decides what comes next.

### Can two products share one factory process?

Two products can share the order of the stages in a factory process. The rules and the checks fit one product. A team that copies a process still has to write its own rules and its own checks.

---

Source: [Software factory process | Stages and steps | SpecStory](https://specstory.com/learning/software-factories/software-factory-process)
