Why Are Coding Agents So Dumb?

TEXT START: The first time I used a coding agent, I was mesmerized.

The Dissection

This is a field report from the seam between capable models and incompetent control layers. It correctly identifies the harness—not the underlying model—as the current bottleneck: poor delegation, weak planning, serial execution, fragile permissions, bad self-knowledge, and excessive dependence on human supervision.

But it is also a requirements document disguised as a diagnosis. The author wants one system to act as scheduler, manager, model router, security principal, reviewer, estimator, and autonomous employee. The principal-agent explanation is plausible, but the article provides anecdotes rather than proof. It converts an engineering shortfall into executive culpability.

The Core Fallacy

The central error is treating agent failure as missing polish rather than a control and verification problem.

The desired agent must be autonomous enough to eliminate supervision, yet constrained enough to avoid dangerous actions; cheap, fast, and correct; capable of making independent decisions, yet reliably aligned with unstated human intent. Those requirements collide whenever the task is ambiguous or the model is wrong in a convincing way.

Sandboxing limits blast radius. It does not produce correct code. Parallel subagents multiply throughput, but they also multiply plausible errors. Self-review is not independent verification when the same class of model generates and judges the work. Better plans help only if someone—or something—can reliably determine whether the plan is valid.

Under the Discontinuity Thesis, the author also misses the strategic consequence. A competent harness would not preserve developer primacy. It would remove the developer from more of the loop. The complaint is that the human is still needed too often; solving that complaint accelerates the collapse of coding labor.

Hidden Assumptions

• Software tasks can be decomposed cleanly and parallelized without dangerous shared-state interactions.
• Completion and correctness can be recognized automatically.
• An LLM can route work among models without introducing another unreliable layer of judgment.
• Security boundaries and semantic autonomy can coexist without substantial human verification.
• Providers will expose open, interchangeable model access despite quotas, lock-in, and revenue incentives.
• The real objective is developer productivity rather than token consumption, vendor control, or labor substitution.
• Current coding work will remain economically necessary after the harness becomes competent.
• Most failures result from underinvestment rather than limits in reasoning, verification, and coordination.

Social Function

Primary classification: partial truth and transition management, with an ideological-anesthetic effect.

The essay accurately documents the primitive state of current agents. It then frames the historical transition as a fixable product backlog: add routing, sandboxing, planning, monitoring, and delegation, and the problem is solved. That framing lets developers interpret labor displacement as a temporary UX defect instead of a structural threat.

The executive-blame theory also provides a convenient escape hatch. It assigns responsibility to disconnected leaders and benchmarks while avoiding the more consequential conclusion: the requested improvements are precisely the machinery that makes skilled coding participation less necessary.

The Verdict

The article is sharper than AI hype, but structurally shortsighted. It correctly sees that the harness is holding back the model; it fails to see that the harness is also the bridge to replacing the human operator.

The “dream agent” is a blueprint for P1, P2, and P3: cognitive work automated, coordination delegated to software, and human developers reduced to supervisors, indispensable exceptions, or surplus. The author is not defending the old coding economy. He is specifying the machine that will finish killing it.