What Is a Dark Software Factory?
A dark software factory is an AI software factory where no person writes or reads the code. People write specifications and acceptance scenarios. Agents write the code, run the checks, and ship the result, and only machines verify it. Dan Shapiro, who popularized the term in January 2026, describes the top level as "a black box that turns specs into software."
It's the most extreme end of the factory idea, and the most argued about. Here are the levels that lead to it, the teams that say they work this way, what replaces code review when nobody reads the diff, and why most teams should stop one step short for now.
Why "dark"#
The name comes from manufacturing. A lights-out factory is staffed by robots, and robots don't need to see, so the lights stay off. FANUC has run plants like this in Japan since 2001, and Xiaomi opened a heavily automated one in 2024. Addy Osmani makes the software version concrete in Software Factories, Light and Dark: in software, the floor is the diff. A dark factory ships diffs that no human wrote, reviewed, or shipped, verified only by the machines that built them.
The five levels, from autocomplete to the dark factory#
Shapiro's five levels borrow from the levels of driving automation. Like those, they're zero-indexed, so there are six:
| Level | Name | What you do | What the AI does |
|---|---|---|---|
| 0 | Spicy autocomplete | Write the code | Suggests the next line |
| 1 | Coding intern | Write the important code | Writes boilerplate you check line by line |
| 2 | Junior developer | Pair program and review every line | Writes real code with you |
| 3 | Developer | Review nearly everything full-time | Writes most of the code |
| 4 | Engineering team | Write specs, then check results hours later | Plans, builds, and tests |
| 5 | Dark factory | Write specs and scenarios | Everything else, with no human review |
His observation is that each level feels like the last one while you're in it, and that most developers who adopt AI settle well below level 4. Moving from level 3 to level 4 is the big change: you stop reading code as it's written and start judging results. Level 5 removes the reading entirely.
Who runs one#
StrongDM is the best-documented case. In February 2026 its AI team published Software Factories and the Agentic Moment, describing "non-interactive development where specs + scenarios drive agents that write code, run harnesses, and converge without human review." Its rules are blunt: code must not be written by humans, and code must not be reviewed by humans. Its validation runs against scenarios and a "Digital Twin Universe" of systems like Okta and Slack, so agents can test behavior end to end without touching real services (StrongDM's write-up). Simon Willison, who saw the demo in person, wrote it up as the first public example of Shapiro's dark factory level.
OpenAI's harness engineering team sits just below it. Its internal product reached about a million lines with no hand-written code, but people still reviewed what merged; even its automated cleanup pull requests are small enough to review in under a minute (OpenAI).
Consultancies have started selling the idea to enterprises. BCG Platinion's March 2026 work on what it calls both the agentic software factory and the Dark Software Factory describes agents that build, test, and ship around the clock while humans define business intent and review outcomes, and reports productivity gains of three to five times from organizations working this way.
What replaces code review#
If nobody reads the diff, every check that reading used to provide has to exist as a machine check, and it has to be better than reading was. The dark factories that publish their methods lean on the same tools:
- Holdout scenarios. Acceptance scenarios the coding agents never see while they build, so they can't tune their code to pass them.
- Digital twins. Simulated copies of external services, so end-to-end behavior can be tested thousands of times without touching production.
- Contract and property tests. Checks on behavior and invariants rather than implementation details.
- Staged rollouts and monitoring. Small blast radius, fast rollback, and production signals that flow back into the factory as new work.
- Separate checkers. The agent that verifies is never the agent that wrote the code, often running a different model.
The risks#
- Nobody understands the system. Osmani's warning is that if people stop reading, they'll stop understanding the software. When something breaks in a way no scenario anticipated, someone has to reason about code nobody has seen.
- Verification debt. A dark factory is only as good as its weakest check, and gaps in the scenarios are invisible until production finds them.
- Security and supply chain. Agents add dependencies, call tools, and run commands. Without review, policy has to block risky actions before they happen, not after.
- Cost. StrongDM's guidance treats $1,000 of tokens per engineer per day as a floor, not a ceiling. That math works for few teams.
- Accountability. Regulators, customers, and incident reviews still ask who approved a change. "The scenarios passed" has to be an answer your organization accepts.
The practical default: a light factory#
For most teams the useful target is level 4 with the lights on. People stay at the decision points (what to build, which risky diffs to read, what merges, what goes to production), and machines do everything in between. Osmani frames the real job as deciding which checks to build and how much autonomy to delegate, task type by task type.
That's the factory Agentastic is built for. Each agent runs in its own worktree, container, or cloud VM; review passes by Claude, Codex, CodeRabbit, or Greptile run before you open a diff; scheduled agents and Manager Agents keep work moving while you're away; and you decide what merges, from your Mac or from the iPhone Companion. If you want to dim the lights later, start with one boring category of work and the steps in how to build an AI software factory.
Sources#
- Dan Shapiro, The Five Levels: from Spicy Autocomplete to the Dark Factory (January 23, 2026); Simon Willison's summary
- StrongDM, Software Factories and the Agentic Moment and The StrongDM Software Factory; Simon Willison, How StrongDM's AI team build serious software without even looking at the code
- Addy Osmani, Software Factories, Light and Dark (July 20, 2026)
- OpenAI, Harness engineering; BCG Platinion, The Agentic Software Factory
- On this site: what is an AI software factory?, loop engineering, best AI software factory tools
Frequently asked questions#
What is a dark software factory?#
A dark software factory is an AI software factory where no person writes or reads the code. People write specifications and acceptance scenarios; agents write the code, run the checks, and ship it, and only machines verify the result. Dan Shapiro calls it level 5 of AI-assisted programming.
Why is it called a dark factory?#
The name comes from lights-out manufacturing, where a factory floor run entirely by robots needs no lighting because no people work there. FANUC has run lights-out plants in Japan since 2001. In software, the floor is the diff, and a dark factory ships diffs no human has read.
What are the five levels of AI-assisted programming?#
Dan Shapiro's scale runs from level 0, spicy autocomplete, through the coding intern, the junior developer you pair with, and the developer who reviews everything the AI writes, to level 4, where you write specs and check results hours later. Level 5 is the dark factory, a black box that turns specs into software.
Does anyone actually run a dark software factory?#
A few small teams say they do. StrongDM published its rules in February 2026: code must not be written by humans, and code must not be reviewed by humans. It validates behavior with scenarios and a digital twin of the services its product talks to instead of reading diffs.
What replaces code review in a dark factory?#
Machine verification: acceptance scenarios the coding agents never see, simulated copies of external systems, property and contract tests, staged rollouts, and production monitoring that feeds failures back into the queue. The bar for those checks has to be higher than human review was, because nothing else catches what they miss.
What is the difference between a light and a dark software factory?#
In a light factory, people stay at the decision points, such as approving specs, reviewing risky diffs, and choosing what merges, and machines handle the rest. In a dark factory, people leave the floor entirely. Addy Osmani frames the real question as which checks to build and how much autonomy to delegate.