A dark factory is a software delivery model in which AI agents perform most of the production work (writing, testing and documenting code) while senior human engineers define the specifications, review the output and control the trust boundaries. The name borrows from manufacturing, where a “lights-out” factory runs without workers on the floor. In software, the lights are out on the production line; they are very much on in the control room.
Quadralyze runs its entire Software pillar this way. This post explains what actually happens inside, and why the discipline matters more than the automation.
How do agents write production code?
Agents write production code from specifications: a senior engineer defines what must be built and how it will be verified, and agent pipelines generate, test and document the implementation against that contract.
The workflow is spec-driven where it matters and vibe-coded where it flies. For core business logic, integration surfaces and anything security-adjacent, the specification comes first (acceptance criteria, interface contracts, failure modes) and the agents build to it. For exploratory UI, internal tooling and scaffolding, the engineer works conversationally and iterates at speed. Knowing which mode a task belongs to is itself an engineering judgement, and it is one a human makes.
The pipeline behind each change is unglamorous by design: generate, compile, run the test suite, run the linters and security checks, regenerate documentation, and only then present the change for review. An agent’s work that fails any gate never reaches human eyes: the factory rejects it automatically.
Where do humans fit?
Humans sit at the trust boundary: every line that ships is reviewed by a senior engineer, and the boundary between what agents may do autonomously and what requires human sign-off is defined before the build begins.
This is the discipline that separates a dark factory from a pile of unreviewed generated code. Trust boundary architecture specifies, per system, what agents may read, write and execute, and what always escalates. A schema migration escalates. A dependency change escalates. A well-tested refactor inside an established module may not. The boundaries are written down, enforced by the pipeline, and revisited as confidence accumulates in either direction.
Is agent-written code safe to ship?
Agent-written code is safe to ship when it is verified the same way you would verify any code you did not write yourself: with tests, evals, static analysis and human review, applied without exception.
The honest answer is that unverified agent code is not safe, and the industry has learned this the hard way. What changes the calculus is that agents make exhaustive verification affordable. Test suites that a human team would ration become cheap to generate and maintain. Documentation stops rotting because the factory regenerates it with every change. The result, counterintuitively, is that a disciplined dark factory ships code with more verification around it than most conventional teams can afford, not less.
What does this mean for speed and cost?
It means enterprise software in weeks, not quarters, delivered by a small senior team with roughly ten times the output per engineer.
The economics follow directly from the model. The production line runs around the clock; the constraint becomes the quality of specifications and reviews, which is precisely where senior engineers earn their keep. This is the one-person unicorn effect applied to services: one Forward Deployed Engineer, embedded in your team and accountable for the outcome, directing a factory that never sleeps. No bench, no handoffs, no pyramid of juniors learning on your budget.
How do you start?
Start with one well-bounded system, one Forward Deployed Engineer, and trust boundaries agreed before the first line is generated.
The first weeks of a dark factory engagement establish the contract: what the system must do, how it will be verified, and where the trust boundaries sit. The pipeline is then stood up around your repositories and standards, not ours, so everything the factory produces lands in your estate, reviewable and portable. From there the cadence is weekly, visible and measured in shipped, human-reviewed software.
Dark FactoryAgents ShipSpec-DrivenVibe CodingTrust BoundaryWeeks Not Quarters