What Is Dark Factory Software Development?

In January 2026, Dan Shapiro published a blog post that gave a name to something a lot of us had been feeling but couldn't quite articulate. He mapped the progression of AI-assisted software development onto five levels, borrowing from the automotive industry's framework for self-driving cars. At the very top, Level 5, he placed something he called The Dark Factory.

The name comes from manufacturing. Japanese robotics company FANUC pursued highly automated production beginning in the early 1980s and, by the early 2000s, reported robot cells capable of 720 hours of continuous unmanned operation. That is the origin of the "lights-out" image: a factory able to keep producing without people continuously on the floor.

Shapiro's insight was that software development is approaching its own lights-out moment, and not in some distant future.

The five levels

The framework, condensed:

Level 0, Manual. You write code by hand. AI is an afterthought or not present at all. This is already becoming rare among experienced developers.

Level 1, Task delegation. You ask AI to write a unit test, generate a function, scaffold a component. You're driving; AI handles discrete tasks on command.

Level 2, Pair programming. AI is your copilot. You work together in real time. You guide direction, AI generates code, you iterate together. Shapiro estimates 90% of developers who call themselves "AI-native" are operating here.

Level 3, Code review. The dynamic flips. AI writes the code; you review it. Your job becomes reading diffs, approving pull requests, and catching mistakes. You're a manager now, not a maker.

Level 4, Spec-driven development. You write detailed specifications covering what the software should do, how it should behave, and what the acceptance criteria are, then hand them to AI agents. Hours later, you check the results against your specs and tests. You're a product manager, not a programmer.

Level 5, The Dark Factory. Specs go in. Software comes out. The human role is defining what to build and why. The how is entirely autonomous. Like the FANUC factory: dark, because humans are neither needed nor present in the production process.

This isn't theoretical anymore

Two weeks after Shapiro published his framework, StrongDM, an infrastructure access company, publicly described a small internal AI team that had been operating a dark factory since mid-2025 as a deliberately constrained experiment. Three engineers. No human-written code. No human code review. Their internal charter has two non-negotiable rules:

Code must not be written by humans.

Code must not be reviewed by humans.

Their process: engineers write extremely detailed specifications. Not code, but prose descriptions of what the software needs to do, including edge cases, error handling, and acceptance criteria. AI agents take those specs and produce code. Other AI agents review it. Other AI agents test it. If something fails, the agents iterate. The humans only intervene at the specification and validation layers, retaining accountability for outcomes while remaining intentionally excluded from implementation.

Their provocative benchmark for whether the factory is automated enough? If you're not spending at least $1,000 per human engineer per day on tokens, you have room for improvement. That is StrongDM's metric, not a proven industry benchmark.

Simon Willison, co-creator of Django and one of the most respected voices in the developer tooling space, wrote that what the then-stealth team had built "looked very convincing". The team was later revealed to be StrongDM. After visiting StrongDM, he described a process built around detailed specifications and external verification. The human effort shifts toward defining intent and measuring outcomes.

Why "dark factory" is catching on

There are a lot of terms floating around for what's happening in AI-assisted development. "Agentic coding" is the category term, the one Anthropic, OpenAI, Google, and the analyst firms use. "Vibe coding" captured the casual end of the spectrum. But "dark factory" fills a specific gap: it names the extreme, the endgame, the fully autonomous production line.

It's catching on because it's visceral. "Agentic development" is accurate but clinical. "Dark factory" makes you feel the weight of what's changing. It carries the industrial metaphor (assembly lines, factories, production) and applies it to something that has historically been considered a craft.

Jason Calacanis recently amplified the concept to his audience with the phrases "lights out startup" and "no humans touch the code". His framing pushes the question to its provocative extreme: how much of software production can operate without routine human handling?

The answer, based on what StrongDM has demonstrated, is: some already exist.

What this means for software teams and agencies

Most teams aren't anywhere near Level 5. The vast majority of professional software development today happens at Levels 2 and 3. Developers use AI as a pair programmer or have started letting AI draft code they then review. Moving to Levels 4 and 5 requires a shift in process and mindset that tooling alone does not deliver.

In a dark factory, the bottleneck moves from coding to specification.

This goes beyond traditional CI/CD automation. Continuous integration pipelines automate execution; a dark factory automates decision-making within clearly bounded intent, shifting cognition itself into the production system.

The quality of your output is entirely determined by the quality of your input. Vague requirements produce vague software. Detailed, testable specifications produce reliable software. The most valuable skill is no longer writing code. It's writing specs an AI system can execute against: knowing what to build, saying it precisely, and defining what "done" looks like with enough rigor that machines can verify it.

For agencies, the traditional model of selling developer hours and delivering code is giving way to selling outcomes defined by specifications. A team of three experienced engineers running a dark factory pipeline can potentially match the output of a much larger traditional team, because the constraint isn't typing speed or debugging cycles. The constraint is clarity of thought.

None of this eliminates the need for human expertise, but it concentrates it. You need senior people who deeply understand software architecture, system design, security implications, and user experience, because those are the things that go into the specification. What you don't need is someone hand-coding CRUD endpoints or writing boilerplate authentication flows.

The risks nobody should ignore

The dark factory concept is powerful, but the risks are real.

Quality at scale is unproven. StrongDM's experiment is impressive but limited in scope and duration. In CodeRabbit's vendor-authored analysis of 470 open-source pull requests, AI-authored pull requests averaged 10.83 issues per pull request versus 6.45 for human-authored pull requests, about 1.7 times as many. The sample, authorship classification, and vendor interest limit how broadly that result should be applied, but it reinforces the need for independent testing and validation.

Specification debt replaces technical debt. If your specs are wrong, your factory produces the wrong thing faster and more confidently than a human team would. Bad specs at scale could be worse than bad code at scale, because the feedback loop is different. The code "works" according to its tests, but the tests were generated from flawed specs.

The "dark" metaphor cuts both ways. For enterprise buyers who need to trust that their software is secure, compliant, and maintainable, "no human ever looked at this code" can be terrifying rather than impressive. How do you sell confidence in a process that's explicitly designed to exclude human oversight from the production layer?

This is early. We're talking about a concept that was named less than a month ago and has one major public implementation. The trajectory is clear, but the timeline for widespread adoption at Level 5 is uncertain. Most organizations will spend years at Levels 3 and 4 before they're ready for a true dark factory approach.

Where this is heading

The direction is visible even if the pace is debatable. AI models and the tooling around autonomous coding agents, including specification formats, testing frameworks, and context management systems, continue to improve. The economics remain unproven. StrongDM publishes its token-spend target, but not a full comparison of equivalent durable output after validation, retries, maintenance, incidents, and human attention.

The dark factory won't replace all software development any more than robotic factories replaced all manufacturing. Bespoke work, novel architectures, and exploratory research will remain deeply human endeavors for the foreseeable future. But a huge percentage of professional software development is not bespoke. It's well-understood patterns applied to business problems. That's where the factory model excels.

For developers, the career implication is to move up the abstraction stack. The people who thrive in a dark factory world are the ones who can think clearly about systems, write precise specifications, design test strategies that catch real failures, and make architectural decisions. The people at risk are those whose primary skill is translating already-clear requirements into code, because that's exactly what the factory automates.

For agencies and consultancies, the opportunity is to become the team that clients trust to run their dark factory. Not everyone will build this capability in-house. The companies that master the specification-to-software pipeline and can deliver reliably at this level will have an enormous competitive advantage.

The lights are going out. The only questions are how fast, and who's ready.