AI agents remove the signal that told you to refactor

Rodrigo Rosenfeld Rosas makes a sharp point about what changes when agents write most of the code. For decades, the trigger to refactor was simple and human: you got lost. When a file grew too tangled to hold in your head, you stopped and cleaned it up, because you had no choice. Modularity, he argues, exists because our attention is finite, so we split systems into pieces small enough to understand one at a time. Agents don't get lost. They can move through tangled code without the discomfort that used to force a rewrite, so the signal that told a team its code was decaying never fires.

The result is a system that keeps working while quietly becoming impossible for its owners to reason about. Code review turns into rubber-stamping once reviewers can no longer follow the changes, and trust inverts: teams come to rely on the agent precisely because they have stopped understanding the code themselves. Rosenfeld notes there is a cost argument too, since tangled code takes more tokens and context to modify and raises the odds the agent hallucinates. His fix is not to slow down but to restore the checkpoint on purpose: keep refactoring as a deliberate habit, and tell the agent to flag rising complexity and propose ways to break it apart. You can read his full argument here.

Why it matters

If your team ships code through agents, the old cue to refactor is gone, and nothing will replace it unless you add it back. Make complexity something the agent must report, or you will find out your system is unmaintainable only when you need to change it by hand.