The premise felt irresistible: give an AI agent a high-level feature spec, walk away, and come back to working software in production. No pull requests to review, no standups, no bottlenecks. Pure output. The dream had a name — the “dark factory” — borrowed from manufacturing, where fully automated plants run without lights because no humans are inside.
That framing has been circulating for a while now, and it keeps attracting serious people who should know better. It’s worth being precise about why it doesn’t hold.
The Gap That Doesn’t Close
The case against fully autonomous development is not that agents build badly. Modern coding agents are genuinely impressive at the mechanical work of implementation. The problem lives one layer up: intent translation.
LLMs keep getting better at writing code. What they do not get better at is understanding what we actually want. Every time a feature description gets handed to an agent, some fidelity is lost — the edge cases no one thought to mention, the implicit constraints that seemed obvious, the integration points only someone who has lived with the codebase would know about. That gap does not close as models improve. It is a property of the handoff, not a property of the model.
There is a second, less obvious failure: maintainability drift. Agents tend to sprawl codebases in ways humans do not. They produce solutions that pass the tests at hand, not solutions that fit the surrounding architecture. Without human code review in the loop, entropy compounds quietly across releases until it becomes expensive to undo. Multiple practitioners who started with fully autonomous setups have reported the same trajectory: eventually adding human review back in, because the alternative was a codebase that technically worked but that no one could extend.
A Factory That Actually Runs
What has shown to work is a lighter version of the same idea — one that preserves most of the automation while inserting humans at the points where intent and judgment actually matter.
The key structural difference is bounded scope. Instead of handing the agent the whole application, each release starts with an epic document — roughly ten to twenty tickets’ worth of work — that explicitly names both what is in scope and what is out. That constraint alone dramatically reduces the surface area where the agent can go sideways.
Four phases define the loop:
Planning stays human. The product requirements, architecture decisions, and overall direction are written by a person. This phase also defines holdout scenarios — test cases kept hidden from the builder agent. The goal is to prevent the agent from overfitting its implementation to the tests it can see, giving the appearance of correctness without the substance.
Ticket splitting can be automated. The factory takes the epic, breaks it into issues, maps dependencies, and labels parallel versus sequential work. Whether a human reviews this step is configurable by complexity and risk.
The core loop runs in parallel. Each ticket moves through claim, complexity routing (simple tickets get a fast path; complex ones get a fuller staged workflow), implementation, automated validation (the agent tests the app the way a user would — clicking, typing, checking results), code review, and iteration. Max retries prevent infinite loops. A manager agent surveys the parallel workers periodically and escalates genuine blockers to a human.
Staging is where the human looks again. After a batch of tickets merges, a person actually uses the software. Anything off becomes a new issue; the factory picks it up. Promotion to production only happens once staging passes.
What Makes This Practical at Scale
Not every step in the loop needs the most capable — and most expensive — model. Planning and architecture calls warrant the most powerful reasoning available. Simpler nodes — ticket picking, straightforward builds, shipping — run on lighter models. Running hundreds of build cycles a week becomes viable when the compute cost is matched to the cognitive weight of each step.
The files that encode the project’s intent — engineering direction documents listing what is out of scope — are locked. The factory reads them but cannot modify them. A simple guard that preserves the human’s framing across every automated cycle.
The Boundary Worth Keeping
The dark factory was always an attractive abstraction. The version of agentic development that actually holds up is one that treats automation as covering the mechanical work, while humans own the layers where intent, judgment, and architectural taste matter: planning, holdout definition, and staged validation.
That boundary is not permanent. As tooling matures, some of what humans do today in staging review will become automatable. But the planning layer — where what we want meets what the agent will build — looks like it stays human for longer than most optimists expect.
Text summarized and optimized using Anthropic’s models and reviewed by a human.