Harness Engineering Won't Save the Dark Software Factory

The pitch for the "dark" software factory is seductive: agents pull tickets, write the code, review each other's PRs, and ship to production while humans watch dashboards. HumanLayer ran that experiment for real — fully lights-off starting July 2025 — and within four months they were rewriting subsystems by hand and tracing a production bug down through layers of code no human had ever read. Co-founder Dex Horthy's post-mortem, "Why Software Factories Fail (or: harness engineering is not enough)," hit the Hacker News front page this week, and it deserves the attention. Not because a dark factory failing is surprising, but because of where Horthy pins the blame.

The fashionable answer to unreliable agents right now is more harness: better sandboxes, better tools, better gates, more deliberate context management. Horthy's argument is that the harness isn't the bottleneck. The models themselves are trained in a way that systematically erodes codebases, and no amount of scaffolding around a fixed model can compensate.

The verifier is the product

Coding models get their final polish from reinforcement learning against verifiable rewards: SWE-bench-style tasks that resolve to pass or fail in seconds. That training loop is why agents got good so fast, and it's also the flaw. A test suite going green is instant feedback; the cost of a bad architectural decision arrives weeks or months later, long after any signal could reach the model that made it. There is, as Horthy puts it, no penalty for eroding maintainability.

So models default to whatever makes tests pass now: a try/except wrapped around everything, a lazy type cast, logic duplicated instead of refactored. Each choice is individually invisible to the verifier and collectively fatal to the codebase. This is Goodhart's law running at token speed — and it's why the obvious escape hatch, using a model to review the code, doesn't hold. Horthy's version of the objection is the sharpest line in the essay: "if a model could reliably tell good code from bad, it might have written the good version to begin with."

If that diagnosis is right, it changes what kind of problem this is. A harness bug you can fix this sprint. A training-objective bug you wait on the labs to fix — and design your process around in the meantime.

The counterexample that proves the rule

The strongest apparent rebuttal comes from OpenAI itself. Its harness engineering write-up — the post that put the term into circulation — describes the Frontier team running a Codex-driven codebase past a million lines with essentially no human-written code, burning on the order of a billion tokens a day, merging without human review. If dark factories can't work, what's that?

Look at the preconditions. It's a greenfield codebase organized for agent legibility from the first commit, operated by people with direct influence over how the model is trained, with verification infrastructure most teams will never approximate. That's not a refutation; it's a boundary condition. Lights-out manufacturing has the same shape — FANUC has run robots building robots since 2001, but only because the quality gate at the end of the line can actually measure what matters about the product. Addy Osmani's framing in his response to Horthy's essay is the right general rule: you can grant autonomy only in proportion to what you can cheaply and reliably verify. Maintainability is precisely the property today's automated gates can't see.

The fleet data is in

What elevates this above dueling anecdotes is that the telemetry now exists. Faros AI's 2026 "Acceleration Whiplash" report analyzed two years of engineering data from about 22,000 developers across 4,000-plus teams. The gains are real: heavy AI adopters completed 66% more epics per developer. So are the costs: bugs per developer up 54%, incidents per pull request up 242.7%, and 31.3% more PRs merged with no review at all. Code churn — code written, then rewritten shortly after — rose 861%.

That churn number is the tell. It's what servicing comprehension debt looks like in aggregate: teams shipping code nobody understood, then paying for the understanding later, with interest. HumanLayer's four-month blowup wasn't an outlier; it was the same curve on a shorter timescale.

What to do with this

If you're evaluating agentic workflows for a team this year, the practical takeaways are concrete:

• Keep the merge gate, and instrument it. Unreviewed-merge rate is now a leading indicator of trouble. If it's drifting toward that 31% figure, you're building a dark factory by accident.
• Move human review upstream. Reviewing a 4,000-line generated diff is where judgment goes to die. Reviewing the plan — the architecture sketch, the data model, the type signatures — before the agent runs is where an hour of senior-engineer time actually multiplies. This is the strongest idea in Horthy's proposed workflow: phase-gated planning (product intent, system architecture, program design), then agents implementing in vertical slices.
• Build in vertical slices. Left alone, agents plan horizontally — database, then service, then API, then frontend — and integration problems surface at the end, where they're most expensive. End-to-end slices keep every increment testable.
• Track incidents per PR and churn, not just throughput. Faros's data says throughput metrics alone will tell you a flattering lie for about two quarters.
• Budget for 2–3x, not 100x. That's Horthy's revised estimate after the failed experiment, and it matches what the quality-adjusted fleet numbers support.

Where this lands

The dark factory isn't wrong forever — it's wrong now, for any team whose codebase has to outlive the quarter. The verifier gap is a known problem, and there's real work underway on longer-horizon benchmarks and mutation-based evaluation that could eventually train models to feel the cost of bad design. Until that lands in a frontier model, harness engineering is table stakes, not salvation. The teams winning with agents in 2026 aren't the ones who removed humans from the loop; they're the ones who moved the humans to the one place in the loop where judgment still compounds — before the code gets written.