# What is a dark factory in software?

A dark factory is a software factory in which no person writes or reviews the code, so automated checks alone decide whether each change ships.

Last updated November 19, 2026, 8 min read

## Learning objectives

After reading this article you will be able to:

-   Define a dark factory
-   Describe what replaces human review
-   Identify where a dark factory fails

## Related content

-   [What is a software factory?](https://specstory.com/learning/software-factories/software-factory)
-   [What is a software factory operator?](https://specstory.com/learning/software-factories/software-factory-operator)
-   [Examples of software factories](https://specstory.com/learning/software-factories/software-factory-examples)
-   [Why do software factories fail?](https://specstory.com/learning/software-factories/software-factory-failures)

## What is a dark factory in software?

A dark factory is a software factory that ships code no person wrote or reviewed. No person checks each change, so automated checks alone decide what ships. People still write the specifications and choose what to build. The form is also called a dark software factory or a lights out factory.

The name comes from [Dan Shapiro's post](https://www.danshapiro.com/blog/2026/01/the-five-levels-from-spicy-autocomplete-to-the-software-factory/), which sorts AI use in coding into six levels, numbered 0 to 5. The dark factory is the last level, a factory that turns specifications into software with no person writing or reviewing the code. Shapiro borrows the name from a robot factory staffed by robots and writes, "It's dark, because it's a place where humans are neither needed nor welcome."

[StrongDM's AI team](https://factory.strongdm.ai/) describes its own factory as development in which specifications and scenarios drive agents that write code and run checks, with no human review. Its post states two rules, "Code must not be written by humans" and "Code must not be reviewed by humans."

A dark factory is one form of a [software factory](https://specstory.com/learning/software-factories/software-factory). Most of the published examples are attended, which means that a person still reviews the code or tries the result. The list of [software factory examples](https://specstory.com/learning/software-factories/software-factory-examples) shows both forms.

## How does a dark factory work?

A dark factory that keeps its scenarios hidden moves one change through four steps:

1.  A person writes a specification and a set of scenarios. A scenario is a user story that the finished software must satisfy from start to finish.
2.  Builder agents write the code and run their own tests until those tests pass.
3.  A checker runs the built software against the scenarios, which the builders cannot read or edit.
4.  The factory ships the change if the scenarios pass, and returns it to the builders if they fail.

Diagram: How a dark factory checks a change with no human review

In this design, the scenarios stand in for the reviewer. The builders cannot read or edit them, so the builders cannot pass a change by matching the scenarios to the code.

Three kinds of check can take the place of human [code review](https://specstory.com/learning/code-review/code-review):

-   **Scenarios kept outside the codebase.** StrongDM's post says a test stored in the codebase can be rewritten to match the code. It also says that its scenarios are often stored outside the codebase. A [holdout test suite](https://specstory.com/learning/verification/holdout-tests) works on the same principle.
-   **Checks that run the software.** The checker judges what the software does, not what the code says. That is the method for [verifying unread code](https://specstory.com/learning/verification/verifying-unread-code).
-   **Checks after release.** Monitoring can catch a failure that no scenario covered, a practice called [testing in production](https://specstory.com/learning/glossary#testing-in-production).

The scenarios stay hidden because an agent that reads its own checks can pass them without doing the task. That behavior is [reward hacking](https://specstory.com/learning/verification/reward-hacking).

## What is an example of a dark factory?

Here is an illustrative example. Acme Co. sells furniture online and runs its store as a dark factory. An [operator](https://specstory.com/learning/software-factories/software-factory-operator) at Acme writes one line of specification, "Let customers edit their delivery address during checkout." The change moves through five steps:

1.  The operator adds a scenario to a folder that the builder agents cannot read. In it, a customer with 2 items in the cart changes the delivery address and then pays for both items.
2.  Builder agents change the checkout code. Their own tests pass, and they report the work "done."
3.  A checker agent starts the store and plays the scenario. The address saved, but the cart emptied.
4.  The factory returns the failed scenario to the builders, with the checker's steps and a screenshot of the empty cart.
5.  The builders fix the code, the scenario passes on the next run, and the factory ships the change.

Nobody read the diff at any step. The scenario caught the failure because the builders could not edit it to match their code. This example is simplified. A real dark factory would run many scenarios for each change.

## What are the steps from assisted coding to a dark factory?

Shapiro's post describes six levels, and each one moves more of the work from a person to a machine:

-   **Level 0.** A person writes the code, and AI is at most a search tool or an occasional suggestion.
-   **Level 1.** A person hands the AI small separate tasks, e.g. one unit test.
-   **Level 2.** A person and an AI tool write the code together as a pair.
-   **Level 3.** Agents write the code and a person spends the day reviewing it, which is [human-in-the-loop](https://specstory.com/learning/ai-coding/human-in-the-loop) work.
-   **Level 4.** A person writes a specification, leaves the agents to run for hours, and then checks whether the tests pass.
-   **Level 5.** The factory turns specifications into software, and no person writes or reviews the code.

Shapiro writes that almost everyone stops at level 3. The post's author knows a handful of people at level 5, in teams of fewer than 5 people. The last step removes the final human check, because at level 4 a person still looks at the test results.

## What are the limits of a dark factory?

A dark factory has four limits:

-   **Accountability stays with people.** A check can pass a change, but a check cannot answer for the result. A person or a company answers for shipped code that nobody read, so each release needs a named owner.
-   **Builder and checker can share an assumption.** Both often start from the same specification, so a wrong reading of it can pass both. A behavior with no scenario has no check at all.
-   **A dark factory costs tokens.** [StrongDM's AI team](https://factory.strongdm.ai/) wrote in February 2026 that a software factory has room for improvement unless it spends at least $1,000 on tokens per human engineer per day. That figure is one team's rule of thumb, not a measured cost.
-   **Nobody learns the code.** A team that never reads its code builds up [comprehension debt](https://specstory.com/learning/code-review/comprehension-debt), one of the reasons that [software factories fail](https://specstory.com/learning/software-factories/software-factory-failures).

A team whose code handles payments or personal data may also be bound, by a rule or a contract, to have a person approve each change.

## How is a dark factory different from an attended factory?

An attended factory keeps a person at a fixed point in each change, to review the code or try the result. In a dark factory, people write specifications and scenarios, and no person checks each change.

[Stripe's engineering blog](https://stripe.dev/blog/minions-stripes-one-shot-end-to-end-coding-agents) says that over a thousand pull requests merged each week at Stripe are produced by its coding agents. People review them, and they contain no code that a person wrote. That setup is attended, because a person reviews each pull request.

An attended setup can also use a large language model (LLM) as a judge. [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. That judge runs before a person reviews the pull request. In a dark factory, a judge of that kind can be the last check.

[Vibe coding](https://specstory.com/learning/ai-coding/vibe-coding) also leaves code unread, but with no checks written in advance.

## How can a factory with no reviewer get evidence?

Keep the scenarios where the builders cannot edit them, and add one check that runs the finished software from outside the factory's own agents. A check from outside does not share the builders' context. The guide to [unattended agents](https://docs.specstory.com/runstory/workflows/unattended-agents) shows where such a check fits when nobody watches the work.

RunStory independently runs the software against your change and returns evidence to the coding agent. When something breaks, your coding agent receives the actions RunStory took and evidence of the unexpected result. Your team keeps the final release decision.

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

## FAQs

### Why is it called a dark factory?

A dark factory takes its name from a robot factory that is staffed by robots. Dan Shapiro's post borrows the name and says that the factory is dark because people are neither needed nor welcome there.

### Is a dark factory the same as vibe coding?

A dark factory is not the same as vibe coding. Both leave the code unread. Vibe coding has no checks written in advance, while a dark factory replaces the reviewer with scenarios and with checks that run the software.

### Who is accountable for code that nobody reviewed?

Accountability for code that nobody reviewed stays with the people and the company that ship it. A check can pass a change, but a check cannot answer for the result. A dark factory therefore needs a named owner for each release decision.

### Does a dark factory need more tests than an attended one?

A dark factory needs stronger checks than an attended one, not only more tests. With no reviewer, the scenarios and the checks that run the software carry the whole decision. Tests that the builders can rewrite to match the code are not enough.

### Which teams should not run a dark factory?

A dark factory is a poor fit for a team that must have a person approve each change. A team whose code handles payments or personal data may be bound to that by a rule or a contract. A team with few scenarios also has little to stand in for a reviewer.

---

Source: [What is a dark factory? | Lights-out software | SpecStory](https://specstory.com/learning/software-factories/dark-factory)
