How AI agents ship code while you sleep. Why harness engineering is the new craft. And what breaks along the way.
Physical manufacturing has a term for it. Dark factories. Automated production lines that run in the dark because there is no human on the floor. Toyota. FANUC. Every serious manufacturer has one now. Rows of robotic arms working in the dark, only lit when a human walks in for maintenance.
Software is finally catching up.
I have been writing a lot lately about designers over-relying on AI. Cutting corners. Skipping the craft. Shipping brittle work. All still true.
But there is a version of AI that is genuinely the right answer at enterprise scale. A properly trained one. Wrapped in the right harness. Coordinated with real orchestration. This blog is about that version. What it is. How it works. Where teams get it wrong. And what “properly trained” actually looks like when you build it seriously.
What is a dark software factory
A dark software factory is a codebase where AI agents plan, write, test, review, and ship code with no human approval step in the loop. Specs go in. Software comes out. The human role is defining what to build and why. The how is entirely autonomous.
Dan Shapiro put a useful framework around this. He mapped software development onto the NHTSA’s five-level framework for autonomous driving. Level 1 is AI-assisted (a copilot suggesting completions). Level 2 is AI-generated code with human review. Level 4 is spec-driven, where humans write specs and check outputs. Level 5 is the dark factory. Humans define what and why. Everything else is autonomous.
StrongDM publicly revealed in early 2026 that a small internal team had been operating a dark factory since mid-2025. Three engineers. Zero human-written code. Zero human code review. Their internal charter has two non-negotiable rules: code must not be written by humans, and code must not be reviewed by humans.
The infrastructure exists now. Here is how it works.
Why now, not two years ago
The dark factory is not new as an idea. It is new as a working reality.
Two inflection points made it possible. First, the model quality threshold. Leading models from Anthropic and Google now score in the high percentiles on SWE-bench, the industry-standard benchmark for real-world coding tasks. Above roughly 75% on SWE-bench Verified, you have models capable enough for autonomous code work on most enterprise codebases.
Second, the infrastructure layer. In late 2024 and through 2025, teams built the validation harnesses, observability layers, and self-healing loops that make human review unnecessary. That is the piece nobody was talking about a year ago. Everyone was chasing model quality. The winners were building harnesses.
The result: a small handful of teams, StrongDM most publicly, are shipping production code entirely without humans on the floor.
Step 1. The Brief
The human defines what to build. Not how.
The brief is your spec. It includes the goal, acceptance criteria, what must not break, constraints on architecture or dependencies, and explicit non-goals.
Example. Instead of “add rate limiting,” a real dark factory brief looks like: “Add rate limiting to /api/checkout. Must handle 5,000 requests per second per user. Must return HTTP 429 with Retry-After header. Must not affect existing /api/cart endpoints. Must use Redis, already provisioned. Must include tests covering burst traffic and cool-down. Not a goal: dashboard visualization of rate-limit events.”
The clearer the brief, the better the output. This is now the highest-leverage skill in software: writing a spec precise enough to be autonomously executed. Vague briefs produce vague code. Precise briefs produce production code.
The teams that will win are the ones who invest in spec-writing as a discipline.
Step 2. The Planner
A planner agent converts the brief into structured tasks. It reads the codebase, maps dependencies, splits work into parallel branches with clear success criteria.
Most implementations fail here. A weak planner produces conflicting tasks that break during execution. A strong planner produces clean, isolated units of work that agents can execute in parallel without stepping on each other.
Example. Take the rate-limiting brief from above. A strong planner outputs six parallel tasks: (1) add Redis-backed rate-limit middleware, (2) update /api/checkout to use it, (3) write unit tests for the middleware, (4) write integration tests for burst behavior, (5) update API documentation, (6) add observability hooks for rate-limit events. Each task has its own success criteria. Each can run in parallel without conflicting with the others.
The planner is the architect. If the planner is wrong, everything downstream is wrong. Which is why every serious dark factory dedicates its best-tuned model to the planning role, and its cheaper models to execution.
Step 3. The Swarm
Multiple agents work in parallel, each in an isolated Git worktree so nothing clobbers anything else. One writes the code. Another writes tests. A third reviews. A fourth runs security checks. A fifth updates the documentation.
This is the split-and-merge pattern.
Here is where the honest reality shows up. Belitsoft’s 2026 data found enterprises now run 12 AI agents on average. But 50% of them work alone. No coordination. No shared state. No handoff protocol. That is why most implementations fail.
The failure modes are documented and expensive.
Infinite handoff loops. Agent A delegates to B. B delegates to C. C delegates back to A. Nobody owns the task. The loop burns tokens until someone kills it. This is now considered the number one production failure mode in multi-agent systems.
Cascade failures. A bad output at stage one poisons every downstream stage. The “From Spark to Fire” cascade paper published in 2026 found that a single false claim at the start of a hub-and-spoke topology can infect 100% of downstream agents. One wrong context, thirty broken components.
Cost runaway. A dev team’s runaway agent loop can generate 500,000 API calls in a day at 50 cents each. That is $75,000 in a single overnight run. Real teams have lost this money. Twice.
Coordination is not a nice-to-have. It is the whole engineering problem.
Step 4. The Harness
The harness is the validation loop. It is the difference between “AI wrote code” and “AI shipped code.”
A real harness includes multiple layers. Automated tests. Behavior contracts (typed schemas at every agent handoff). Digital twin environments where agents run through user scenarios before merge. Circuit breakers that shut down agents making the same mistake twice. Observability that catches drift before it compounds.
Schema validation at every handoff is the single practice that eliminates the majority of cascade failures. If agent A hands agent B a malformed output, B should reject it and force A to retry, not accept it and propagate the corruption downstream.
If validation fails, the agent iterates. If it passes twice, it ships.
OpenAI’s Harness Engineering paper reports 1 million lines of code, none of it hand-written, shipped at 10x normal velocity through this pattern. Not the model doing the work. The harness making the model’s work merge-safe.
EPAM ran a controlled experiment in early 2026. A feature that typically takes a developer 2 days shipped in 2 hours of autonomous agent work. 30+ files changed. 90% visual fidelity to the original Figma design. Not perfect. But merge-close, in one-eighth the time.
The harness IS the design. Everything else is execution.
What “properly trained AI” actually means
I have been critical of AI misuse in design. That is still true. What is also true: properly harnessed AI is a step-function improvement over anything humans can do alone at enterprise scale.
The distinction is craft.
Vibe coding is asking an AI to write your feature and hoping for the best. That is the version being sold on Twitter. It works for prototypes. It falls apart at scale.
Harness engineering is designing the constraints. The specs. The validation layers. The digital twins. The circuit breakers. The observability. All the things that let AI work autonomously without shipping broken code into production.
Same tool. Different discipline. The tool is genuinely powerful. The discipline is what makes it enterprise-safe.
Where Oranje fits
This is the layer we are building at Oranje. Harness first. Agent orchestration second. Governed velocity, from brief to production, with a real audit trail
Not vibe coding. Not “prompt then pray.” A production-grade dark factory pattern, deployed inside the client’s own codebase, running inside the client’s own governance rules.
Oranje is in beta right now, with our enterprise launch coming soon. 🍊
Closing thought
The teams that will win the next five years are not the ones with the fastest coding assistants. They are the ones with the best harnesses.
Vibe coding is a party. A dark factory is a business.
Build the harness.
Further reading
What Is a Dark Factory Codebase?. The full spectrum of AI coding autonomy levels, with clear definitions of each tier.
Dark Factory Pattern: Moving From AI-Assisted to Fully Autonomous Coding. Practitioner walkthrough of moving from Level 2 to Level 5 autonomy, with real numbers from an 8-engineer team
OpenAI Harness Engineering. 1 million lines of code at 10x velocity through structured repository knowledge and mechanical enforcement of standards.
Multi-Agent in Production 2026: 3 Patterns That Survived. Cascade failure analysis, the $75,000/day runaway agent bill, and what the winners did differently.
Building a Dark Factory with an AI Agent Swarm: What Actually Works. Hands-on 2-hour autonomous frontend build, 30+ files, 90% visual fidelity.
AI Agent Orchestration in Production: What Breaks Past 10K Invocations Per Day. The four primary failure modes at scale, and the infrastructure required to survive them.
The Oranje Co is building infrastructure for the creative economy. Harness-first, agent-orchestrated, governed by design. Currently in beta, with enterprise launch coming soon. getoranje.com
