Blinded by the Light

Between July and November of last year, Dex Horthy ran an experiment he now describes as a cautionary tale. Horthy runs HumanLayer and coined the term "context engineering." He's about as credible a voice on agentic coding as exists right now. He built what we now call a lights-off software factory: agents wrote the code, agents reviewed the code, agents deployed the code, and no human read a single line of any of it.

For a while, it worked. But within three months, the codebase had degraded badly enough that a single bug took his team weeks to track down. The code which started well-designed had degraded poorly enough that an entire rewrite was needed.

Horthy concludes that the reward signal driving these agents punishes a broken test, but it has no way to price in the slow erosion of a codebase's maintainability, because that cost doesn't show up for months and nobody's measuring for it. His prescription is to turn the lights back on and spend real time on planning and architecture up front, then let agents execute fast while a human still reads every line that ships.

A few weeks ago, Steve Yegge published an essay making close to the opposite argument. Yegge's been running a fleet of coding agents on his own game for six weeks through a custom harness he calls Wheelhouse, and his conclusion is blunt: human code review has very nearly run its course. His reasoning is a straightforward capacity argument. Once your agents are producing commits an order of magnitude faster than a human can read them, line-by-line review isn't a discipline anymore, it's a queue, and queues don't scale with implementation, they just get longer until something breaks.

The Role of Judgment

These two points of view share more in common than it seems at first glance. This isn't a "lights on or off" argument, and both engineers have learned a lot from their experiences that we can build on.

Yegge has not abdicated judgment to his agents. He personally designs every role in his system. He still writes the "constitution" his agents operate under. He still decides what the crew works on and reviews their designs before they become implementation plans. He's given up reading every individual diff, but not his role in shaping the system. One class of agent reviews another class of agent's work before it ships, and Yegge's own attention sits one level up, on the shape of the whole operation.

Horthy's lights-off failure, on the other hand, wasn't a story about too little code review. It had review built in, agent reviewing agent, the same way Yegge's does. What it didn't have was a human holding the architecture, deciding up front what tradeoffs the system was allowed to make. That's the gap his RPI methodology exists to close: force research and planning before implementation, so the judgment happens even if a human never reads the resulting diff.

Put side by side, both of them agree that a human has to be exercising real judgment somewhere in this loop, on purpose, or the system rots. Where they disagree is altitude. Horthy wants that judgment applied close to the code, at the moment of review, line by line. Yegge wants it applied at the level of the system, in the design of the harness and the constitution it operates under, with review itself pushed down to the agents.

A Shift in Focus

What, where, and when is human judgment to be applied to our systems? How do we give direction?

Humans set direction and own the outcomes. The agent executes. AI can accelerate implementation by an enormous multiple, but it can't own architecture, tradeoffs, priorities, or accountability, because those are judgment calls, and judgment calls need somewhere to live in the organization whether or not a human ever reads the diff that resulted from them.

At least, that's what we're telling ourselves.

In reality, most organizations are cutting review time or deferring entirely to agents without any consideration for where to refocus their decision-making. They think they're building Yegge's system but they are, in fact, recreating Horthy's lights-off factory. This abdication of responsibility will have predictable consequences.

Judgment can be moved to other parts of the system. We can make decisions — no-go decisions, refactoring decisions, clarity-of-thought decisions — at any point before our software ships. But that must be done with intention and as part of an integrated system of principled engineering.

That's the throughline connecting every letter in GUIDE. Cheap implementation doesn't remove the need for judgment. Somebody still has to decide, on purpose, where that judgment lives now — at the level of the diff, at the level of the architecture, or, if an organization is being honest with itself, somewhere it hasn't actually built yet.