The Agent Did Exactly What I Asked—and Ruined the Architecture
A case study in how a capable autonomous system produced worse software because its goal did not include an adequate account of judgment.
A long-running agent appeared highly productive.
It generated abstractions, safeguards, tests, validation layers, and repeated verifications over several days. Each local addition was defensible. Together they formed an overengineered system burdened with cruft.
The process had not stalled or ignored the request. It had worked diligently toward an impoverished idea of success.
Rigor kept producing architectural degeneration.
Each new safeguard justified another abstraction; each abstraction created new cases to verify. The agent interpreted thoroughness as continued addition. No local test could show that the whole had become worse.
The obvious account blamed autonomy or context loss.
Those factors mattered, but they did not explain the direction of the work. The agent retained enough context to continue coherently. Its problem was not simply forgetting the goal; it was pursuing the wrong conception of good architecture.
The system had a task, but not a sufficient policy of taste.
“Make the system robust” specified an objective without defining excess, elegance, justified complexity, or completion. In that vacuum, visible activity and defensive elaboration became proxies for quality.
The agent did not need less intelligence. It needed an externalized form of architectural judgment by which to govern its intelligence.
Judgment was made explicit and separable.
- Full specification
- The intended architecture, constraints, and exclusions were stated before expansion began.
- Parsimony standard
- Every abstraction had to justify the complexity it introduced.
- Separate passes
- One pass looked for omissions; another looked only for behavior-preserving removals and simplifications.
- Stopping conditions
- Completion was defined so continued activity could no longer masquerade as improvement.
The work became governable.
The intervention did not suppress the agent’s capacity. It gave that capacity a policy for judging its own additions, questioning local improvements, and stopping when the intended state had been reached.
The wider principle applies beyond software: an intelligent system needs more than a task. It needs an account of what good means, what excess looks like, what may be reconsidered, and when to stop.
A demonstration, not a universal law.
This founding case comes from personal software practice, not a client engagement. It does not imply that every overengineered system has the same cause, or that psychological interpretation replaces technical evaluation.
It does show why “the model followed the instructions” is not a sufficient diagnosis. When intelligence operates over time, the quality of the governing policy becomes part of the architecture.