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. In the 1980s, a Japanese robotics company called FANUC built a factory where robots made other robots, 24 hours a day, with no human workers present. They called it a "lights-out" factory. Dark, because no one was there to need the lights. The machines just ran.
Shapiro's insight was that software development is approaching its own lights-out moment. Not in some distant future. Right now.
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
Three weeks after Shapiro published his framework, StrongDM, an infrastructure access company, publicly revealed that a small internal AI team 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 benchmark for whether the factory is automated enough? If you're not spending at least $1,000 per engineer per day on AI compute, you have room for improvement. That's their actual metric.
Simon Willison, co-creator of Django and one of the most respected voices in the developer tooling space, visited the team and called their approach "very convincing." He noted that the key to making it work was an obsessive investment in specification quality and test coverage. The human effort shifts entirely to 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, using the "lights out" framing and asking the question bluntly: how long before we have software companies with humans completely out of the loop?
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 fundamental shift in process and mindset, not just tooling.
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 isn't writing code anymore. It's writing specs that an AI system can execute against. It's knowing what to build, articulating 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. AI-generated code has been shown in several analyses to contain materially higher defect rates than human-written code. A dark factory needs extraordinarily robust automated testing and validation to catch what humans would have caught in review. Companies like CodeRabbit have built entire businesses around this gap.
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 progression is clear even if the pace is debatable. AI models are getting better at code generation with every release. The tooling around autonomous coding agents (specification formats, testing frameworks, context management systems) is maturing rapidly. The economics are compelling: StrongDM's three-person team with high compute costs is still dramatically cheaper than the traditional alternative for equivalent output.
The dark factory won't replace all software development any more than robotic factories replaced all manufacturing. Bespoke work, novel architectures, cutting-edge research. Those 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 robust test strategies, 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.