Why Software Factories Fail: Harness Engineering Is Not Enough

The dream of "lights-off" software factories - where AI agents autonomously ship code without human review - has been a recurring promise since coding agents emerged. But a new analysis from Dex Horthy at HumanLayer argues that the fundamental limitation is not harness engineering. It is the models themselves.

The article, Why Software Factories Fail, landed on Hacker News this week with 341 points and over 240 comments. The discussion revealed a community deeply invested in making AI coding work - and increasingly realistic about what it cannot do yet.

The Core Argument#

Horthy's thesis is straightforward: current AI models excel at solving isolated problems but systematically degrade codebase quality over time. The issue is not that we lack good testing infrastructure or sophisticated agent harnesses. The issue is that models cannot reliably distinguish good architecture from bad architecture.

The article traces the evolution of "software factories" through three phases:

1. 2022 Model: Humans decide, build, review, and ship
2. Agentic Model: Agents replace humans in building, but review still bottlenecks
3. Lights-Off Model: Remove human review entirely; invest in testing and monitoring

Horthy's team attempted the third approach - a fully autonomous factory - in July 2025. They abandoned it after three months. The agent-generated code accumulated architectural debt so quickly that major sections required manual rewrites.

Why Tests Are Not Enough#

The central insight is about feedback loops. Tests provide feedback in seconds. Architectural problems surface weeks or months later. Reinforcement learning cannot capture this delayed cost.

From the article:

"THERE ARE NO GOOD BENCHMARKS for a model's ability to maintain codebase quality. Existing evaluations measure pass/fail rates on discrete tasks, not the subtle architectural erosion that makes future changes increasingly difficult."

Models trained via RL optimize for whatever metrics the training loop rewards - typically binary pass/fail signals. If a model could reliably distinguish good code from bad, it might have written the good version initially. But maintainability has no fast oracle.

What HN Is Saying#

The Hacker News discussion surfaced several perspectives that extend Horthy's analysis.

On the discipline gap: One commenter from the StrongDM AI Lab pushed back on the framing, noting that teams seeing the best results with AI were already high-discipline and high-hygiene before AI. "In order for coding with LLMs to go well, there has to be more rigor, more discipline, more good engineering hard-assedness." (link to thread)

On formal verification: Multiple commenters noted that prompts alone cannot steer agents to the precision needed. One developer at Autodesk shared a taxonomy of constraint mechanisms: generative constraints (to shape output), interpretive constraints (to shape how the model understands code), and elicitative constraints (to help the model ask the right questions).

On the consulting pivot: StrongDM's dark factory experiment is now a consulting company (Diffusion.io). Several commenters pointed out this is a familiar pattern - when products cannot stand alone, companies pivot to services. Palantir and Salesforce follow similar trajectories.

On review itself: One of the most upvoted threads questioned whether AI should be used to replace code review or to improve it. The consensus: review serves multiple purposes beyond correctness - knowledge sharing, architecture consistency, maintainability signaling. Automating only the "find bugs" slice misses most of the value.

The Context Engineering Response#

If harness engineering is insufficient, what actually helps? Horthy points to "context engineering" - front-loading alignment before code generation begins.

The practical recommendations:

1. Invest in planning discussions before coding. Thirty minutes of architecture conversation with the model can save hours of review and rework downstream.

2. Maintain human involvement at the design level. Strategic oversight on system architecture prevents problems that no amount of testing will catch.

3. Apply the Theory of Constraints. Recognize what models do well (isolated problem-solving, boilerplate generation, refactoring with clear patterns) versus what they do poorly (system design, long-term maintainability, architectural judgment). Optimize workflows around those constraints.

The takeaway is not that AI coding is broken. It is that the "lights-off" framing was always wrong. Human-agent collaboration is the productive model. Full automation is not.

Why This Matters for Developers#

The timing is notable. We are in a period where AI coding agents are shipping features faster than ever - Codex, Claude Code, Cursor, Kiro - yet production deployments keep surfacing the same patterns. Agents work well inside tight loops with clear verification. They struggle when the feedback signal is diffuse or delayed.

For teams evaluating AI coding tools, the implication is clear: invest in the context layer, not just the model. The right CLAUDE.md, the right test scaffolding, the right architecture documentation - these matter more than which model you choose.

The article also validates a pattern we have covered before in Agent Evals Need Baseline Receipts and AI Code Review Bottleneck: benchmarks measure the wrong things. Pass rates on SWE-bench do not predict production success. What predicts production success is whether the agent can operate inside a context that encodes your team's standards.

The Honest Position#

Horthy's conclusion is worth quoting directly:

"Harness engineering won't substitute for the core limitation: models lack reliable mechanisms to optimize for maintainability. The solution requires human-agent collaboration, not automation of all phases."

The Hacker News discussion largely agreed. The arguments were about degree, not direction. How much human involvement is needed? At what points in the loop? How do you scale review when agents generate code 10x faster?

Those are the right questions. They assume AI coding is here to stay - and that the work is figuring out the collaboration model, not waiting for a magical fully-autonomous future.

Continue Reading#

• 12 Factor Agents: Production Principles
• Agent Evals Need Baseline Receipts
• AI Code Review Bottleneck
• Context Engineering for Coding Agents
• Why Code Cleanliness Affects AI Coding Agents

Sources#

• Why Software Factories Fail - HumanLayer, July 2026
• Hacker News Discussion - 341 points, 242 comments
• StrongDM AI Lab Weather Report
• Diffusion.io - StrongDM's consulting pivot