# Why do software factories fail?

Software factories fail when no stage runs the product, when work is lost or the queue stalls with no alert, or when the codebase gets worse over time.

Last updated November 19, 2026, 9 min read

## Learning objectives

After reading this article you will be able to:

-   List the common ways a factory fails
-   Recognize a failing factory from its signals
-   Apply a rule after each failure

## 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)

## Why do software factories fail?

Software factories fail when their process has a gap that no agent reports. One gap is a missing stage that runs the product, which leaves the builders' own report as the only check. Factories also lose work, stall with no alert, and let the codebase get worse while nobody reads it.

A [software factory](https://specstory.com/learning/software-factories/software-factory) is a repeatable process in which coding agents take work from a queue, build it, check it, and ship it. A factory failure is a fault in that process.

Most of these failures raise no signal. The tests pass, continuous integration (CI) stays green, and no agent reports an error. The accounts below come from teams that run factories or background coding agents, so each figure is one team's own report.

## What causes a software factory to fail?

The published accounts describe five causes.

### What happens when no stage runs the product?

A factory with no stage that runs the product ships whatever its builders report. That report is a [completion claim](https://specstory.com/learning/verification/coding-agent-done-claims), and the builders' tests come from the same context as their code. In 35 of 51 recent phases of [one operator's factory](https://www.meditationsontech.com/p/building-a-software-factory-aint), the build step reported the work done and the verify step still found a problem. No study ranks factory failures. In the accounts cited here, this failure has the highest reported rate.

A judge built on a large language model (LLM) also stops finished work. [Spotify's engineers](https://engineering.atspotify.com/2025/12/feedback-loops-background-coding-agents-part-3) report that, out of thousands of sessions of their background coding agent, an LLM judge vetoes about a quarter. The post says the most common trigger is an agent that goes outside its instructions. It also names the most serious error, a pull request that "passes CI but is functionally incorrect." A result of that kind is a [false pass](https://specstory.com/learning/verification/false-pass).

### How does a factory lose work or stall with no alert?

A factory can lose work and stop working while no alert goes out. In [one operator's published log](https://www.meditationsontech.com/p/what-its-like-to-operate-a-software), a cleanup loop removed 83 [git worktrees](https://specstory.com/learning/ai-coding/parallel-coding-agents), including one that held uncommitted work. In the same log, a full [context window](https://specstory.com/learning/ai-coding/context-engineering) left the queue idle for 12 hours.

The log says that the coordinating agent's next scheduled start failed and nothing alerted the operator. That log covers a second factory, and the count of phases above comes from the same operator's earlier factory.

### Why is a silent checker read as a pass?

A checker that crashes returns no answer, and a script can read no answer as success. The post about the operator's earlier factory describes that case. A checker agent crashed, the setup read the silence as a pass, and fresh checker agents then found problems in the same work. That factory now counts a crash as needs work.

### What goes wrong when one agent picks up another agent's work?

Agents that share one checkout can pick up each other's files. In the same post, a builder agent ran `git add -A`, which added another agent's unfinished work to the next commit. The rule that followed is short, "Only the committer commits."

### Why does the codebase get worse while nobody reads it?

Passing tests do not show that code is getting harder to change. [One published essay](https://github.com/humanlayer/advanced-context-engineering-for-coding-agents/blob/main/wsff.md) on factory failures reports that its author's company stopped reading its agents' code in July 2025. In November 2025, the company chose to rewrite the code from scratch, and a cofounder laid out its patterns by hand.

The author argues that models "can't maintain and improve codebase quality over time" without "a decent amount of human steering." The slow decline is a form of [technical debt](https://specstory.com/learning/code-review/technical-debt). The team's lost knowledge of its own code is [comprehension debt](https://specstory.com/learning/code-review/comprehension-debt).

## What does a failing software factory look like?

Here is an illustrative example. Acme Co. sells furniture online and builds its store with a software factory that has builder agents and a test suite, but no stage that runs the store. An operator at Acme asks for one change, "Let customers edit their delivery address during checkout." The failure unfolds in five steps:

1.  Two builder agents change the checkout code and report the work "done."
2.  An integrator agent runs every test, and every test passes.
3.  The factory ships the change that evening.
4.  The next morning, a customer changes the delivery address and opens the cart. The address saved, but the cart emptied.
5.  The operator sees abandoned checkouts in the morning report.

Three signals were visible before the customer arrived:

-   **Every report was clean.** No phase that night came back with a finding.
-   **No report carried evidence.** Each one said "done" and listed test results, with no record of anyone using the store.
-   **Nothing ran the product.** The factory had no step between the tests and the release.

This example is simplified. A real factory would also have to find which of the night's changes emptied the cart.

## How can teams reduce software factory failures?

Most of these causes have a matching practice:

-   **Add a stage that runs the product.** A [check stage](https://specstory.com/learning/software-factories/software-factory-verification) starts the software and uses the change. It reports pass or needs work, with evidence.
-   **Count silence as a failure.** A checker that crashes or returns nothing has not passed the change.
-   **Alert on a stopped queue.** A factory with work waiting in the queue and no agent running should alert the [operator](https://specstory.com/learning/software-factories/software-factory-operator).
-   **Let one agent commit.** Builders write files, and a single agent adds them to the commit.
-   **Audit the codebase with a second model.** In the operator's earlier factory, a different model scores the codebase every few days, and its findings go back into the queue as ordinary tasks. The essay's author goes further and brings human code review back.

Diagram: Where a software factory fails, and the practice for each place

Each failure sits at one place on the line, and so does its practice. Two of the five sit at the check stage.

After each failure, the team finds the cause with [root cause analysis](https://specstory.com/learning/debugging/root-cause-analysis) and writes a rule that stops the same failure from happening again. [One operator's post](https://www.meditationsontech.com/p/building-a-software-factory-aint) puts the practice in one line, "Add a line to the file every time you are wrong." The guide on how to [build a software factory](https://specstory.com/learning/software-factories/building-a-software-factory) shows where that rules file sits.

## How is a factory failure different from a failed build?

A failed build is visible at once. A compiler or a test stops, CI shows a red status, and the change does not merge.

A factory failure usually raises no signal. The build is green, the report says "done," and the fault is in the process around the code. One missing stage affects each change that passes through, so the failure repeats until the process changes.

A failed build needs a code fix. A factory failure needs a change to the process, e.g. a rule in the rules file. Changes that ship unchecked in the meantime add to [verification debt](https://specstory.com/learning/verification/verification-debt).

## How can a factory catch a failure before it ships?

Put one stage between the tests and the release that runs the finished software, and count a missing answer from it as a failure. A check from outside the factory's own agents does not share their context. The [workflow guides](https://docs.specstory.com/runstory/workflows) show where such a check fits in each way of working.

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 the most common software factory failure?

The most common software factory failure, in the accounts cited on this page, is a change that the builders report as done while it still has a problem. No study ranks the failures across many factories. A stage that runs the product is the check that finds this one.

### Can a software factory lose work?

A software factory can lose work. One operator's published log describes a cleanup loop that removed git worktrees, including one that held uncommitted work. A factory can also stall, with a queue that sits idle while no alert goes out.

### Why does a factory's queue stop without warning?

A factory's queue stops without warning when the agent that drives it fails and nothing watches that agent. In one operator's published log, a full context window left the queue idle, and the coordinating agent's next scheduled start failed. An alert on a stopped queue closes that gap.

### Do coding agents make a codebase worse over time?

Coding agents can make a codebase worse over time when nobody reads or audits the code. The author of one essay on factory failures argues that models cannot maintain codebase quality without human steering. Passing tests do not show the decline, so a separate audit has to look for it.

### How often should a second model audit the codebase?

An audit by a second model has no agreed schedule. One operator's post describes a different model that scores the codebase every few days. Its findings go back into the queue as ordinary tasks.

---

Source: [Why do software factories fail? | Failure modes | SpecStory](https://specstory.com/learning/software-factories/software-factory-failures)
