AI agents never get lost in the code, and that's why refactoring never comes

By Zendoric · September 3, 2026.

For years, the brake on unreadable code was accidental: an engineer would get lost in a tangled function, could not hold it in their head and decided to refactor before going any further. Developer Rodrigo Rosenfeld Rosas argues in a recent essay that this signal no longer fires. The AI agents that today write much of the code do not have limited working memory: they can read a tangled function, trace every call and add the next branch without tiring or getting lost. The result, according to Rosenfeld, is that refactoring —that structural cleanup of code that human fatigue used to force— stopped happening almost without anyone noticing.

The phenomenon already has a name: Oleg Lola, CEO of MobiDev, calls it "vibe debt" in a Forbes article from July 2026 on undisciplined AI-assisted programming ("vibe coding"). According to Lola, that technical debt —dependencies the AI hallucinates, hidden vulnerabilities, architectures nobody fully understands— piles up "20 times faster" than traditional technical debt. It used to take about three months to hurt; now, by his reading, that window is compressed drastically.

The blind spot Rosenfeld points to is more troubling than the technical debt itself: when no member of the team can reason about key parts of the system without going through the agent, code reviews become an empty formality, because the reviewer can no longer follow the change they are approving. The team ends up trusting the agent precisely because it stopped understanding what the agent builds: the exact inverse of how technical trust should work. And the loss is gradual, with no moment of alarm, because the alarm depended on a human getting lost —and now whoever navigates the code is no longer human.

Rosenfeld does not stop at the moral argument: there is an economic reason to keep code modular even when working with agents. A tangled file forces the agent to read more files, trace more branches and consume more tokens —the units of text billed by each call to a language model— for every change. A system of small, self-contained modules is cheaper to operate and reduces the ambiguity that triggers hallucinations. The same modularity that used to fit in a human head now fits in the context window the agent can process accurately: good economics, not just good coding style.

The pressure to accelerate with agents, meanwhile, is no longer an option for startups: it is the big platforms' bet. On August 5, 2026, Meta unveiled its coding agent Muse Code, built on the Muse Spark 1.2 model and able to plan changes, write code and validate results in large repositories, as reported by SiliconANGLE. Alexandr Wang, head of Meta's Superintelligence Labs, told CNBC that his strategy is to compete on price: a service tier "more than 10 times cheaper" than the competition, in exchange for being able to use usage data to improve the product. In parallel, Microsoft began pulling licenses for Claude Code —Anthropic's coding agent— in its Experiences + Devices division (Windows, Microsoft 365, Teams, Outlook and Surface) to push its engineers toward its own GitHub Copilot CLI, according to The Verge. CEO Satya Nadella himself had previously revealed that up to 30% of Microsoft's code is already written with generative AI.

Our reading: this is, once again, the pattern we have been observing at every frontier where AI gains autonomy. The bottleneck is not capability —agents already write plenty of code— but governance: the mechanisms that force a system to remain auditable, explainable and maintainable by humans. We already saw it with algorithmic decisions that fire or ban people without giving reasons: the demand was not that they be more accurate, but that they be accountable. Something similar happens with code. The agent's speed is not the problem; the problem is that, unintentionally, it removed the only free brake we had.

In the short term the risk is concrete and deserves to be taken seriously: founders who reach a Series A round with a product built at full speed and discover that this MVP is a black box that not even their own senior engineers can maintain, migrate or audit with confidence. It is the kind of debt that goes unnoticed until you have to scale, switch providers or convince a senior engineer to sign off on a change they do not understand. Rosenfeld is right to insist that ultimate responsibility remains human: the agent can flag the modules that have become too large or too expensive to maintain, but deciding to refactor is still a product governance decision, not one that can be delegated entirely.

In the long run, however, Rosenfeld's own economic argument points to where we believe this is heading: if modular code is cheaper for the agent just as it was for the human, architectural discipline does not disappear with AI, it becomes more profitable with it. The teams that treat code governance —clear boundaries between modules, real review, an explicit budget for refactoring— not as a luxury but as part of the cost of operating agents will build systems that scale more cheaply than those that blindly trust the agent's speed. That is the real abundance that agentic development promises: not infinite software without discipline, but small teams able to sustain large systems without complexity devouring them, as long as someone —a human, or the agent itself configured to flag it— keeps asking the question that fatigue used to ask.