The Agentic Coding Trap: Why the Productivity Promise Is Burning Developers Out

The pace of software development has undergone unprecedented compression. What until recently was simply “programming” is now called trad coding (traditional coding), a process that required writing line by line, respecting the natural flow of problem-solving and the time the brain needs to process logic. Today, that flow has been run over by the rise of AI agents.

The promise is seductive: the human takes on the role of “orchestrator”, delegating heavy implementation work to autonomous agents. However, this shift has eliminated the critical “breathing room” moments that allowed a solid mental model to form. Working with agentic flows often puts us in a state of cognitive “cold start”: the code appears ready-made before our eyes, like the tattoos in the film Memento, demanding an exhausting reverse-engineering effort to understand a context whose creation we did not actively participate in.

Decision fatigue is the next major bottleneck

Managing agents turns deep intellectual work into a sequence of variable psychological rewards, a mechanic comparable to gacha systems or slot machines. You pull the AI lever, receive an output, and immediately need to validate it. This dynamic creates cognitive fatigue.

The core problem is that supervising multiple agents is fundamentally more exhausting than executing the tasks yourself. The work drains the professional through constant judgment and vigilance. Operating in this mode of intense supervision can leave the “brain cooked” after only four or five hours, compared with eight or ten hours of sustainable productivity in a traditional workflow. The volume of architectural decisions and course corrections per minute requires a mental endurance that human biology cannot sustain in the long run without resulting in burnout.

The supervision paradox: overuse erodes the required competence

We are living through a dangerous contradiction that Anthropic defines as the “supervision paradox”: to use models like Claude effectively, you need high-level coding skills; yet excessive dependence on these tools causes those very skills to atrophy.

The evidence of this competence erosion is already tangible:

• Technical atrophy: Anthropic data points to a 47% drop in debugging skills among developers who use AI aggressively.

• The junior barrier: early-career professionals lose around 50% of the learning process when they “abdicate the friction” of direct writing. Without manual effort, the “muscle” of critical thinking does not develop.

• Impact on seniors: the risk is not limited to newcomers. Simon Willison, a developer with 30 years of experience, reported that intensive AI use harms the firm mental model of applications, making each new feature harder to reason about.

• Corporate reality: Sandor Nyako, Director of Engineering at LinkedIn, banned his team of 50 engineers from using agents for tasks that require “critical thinking or problem-solving”, emphasizing that competence is born from confronting difficulty.

“The people who are going all-in on AI agents right now are guaranteeing their obsolescence. If you outsource all your thinking to computers, you stop updating yourself, learning, and becoming more competent.” - Jeremy Howard

Speed is not quality: when volume outruns understanding

AI reverses the traditional priorities of development. Where we once sought clarity and concision, we are now flooded by volume. It is crucial to understand that AI is not a new “abstraction layer” (as C++ was to Assembly); it is an increase in ambiguity. We have replaced deterministic systems with probabilistic systems that generate a “debt of understanding”.

The inversion of priorities:

• Traditional priorities:

  • 1. Code comprehension;

  • 2. Alignment with standards;

  • 3. Concision;

  • 4. Speed.

• Agentic priorities:

  • 1. Speed;

  • 2. Generation volume;

  • 3. Ambiguity (instead of clarity).

Dax, creator of OpenCode, argues that “coding is planning”. For many developers, typing the types, defining the functions, and organizing the folder structure is the process through which the brain discovers what needs to be done. When you outsource the typing, you outsource the thinking process itself.

The risk of technological lock-in and token uncertainty

Dependence on agents creates a systemic vendor lock-in vulnerability. During recent provider outages (such as Claude Code), entire teams were paralyzed, unable to perform tasks that previously depended only on a keyboard and intellect.

Beyond operational vulnerability, there is financial volatility. While the cost of an employee is fixed and predictable, token costs are a “constantly moving target”. Models are launched, “nerfed”, or repriced, making the cost of productivity uncertain. We are turning the ability to solve problems, once the professional’s intellectual asset, into a paid third-party service. As the influencer Primeagen aptly puts it, in fully agentic flows, “the model providers essentially own you”.

A new approach: AI as utility, not replacement

To avoid obsolescence, Lars Faye proposes a paradigm shift: downgrade the role of AI. The strategy is to use AI not as “Data” (the autonomous Star Trek character who replaces human functions), but as the “Ship’s Computer” (the ship computer, a passive query tool that provides data on demand while the human pilots).

Practices for a sustainable workflow:

• Active engagement: stay involved in implementation. Write 20% to 100% of the code manually, depending on complexity.

• Volume limit: never generate more code than you can thoroughly review in a single session.

• Use of pseudocode: write the logic in pseudocode before requesting generation. This closes the gap between human intent and machine output.

• AI for exploration, human for execution: use models for specification brainstorming and research, but personally facilitate final execution to ensure understanding.

The value of friction in learning

Real code comprehension requires tangible and frequent engagement. The “friction” of solving a difficult problem is not a waste of time; it is the only path to consolidating knowledge. By eliminating all difficulty from programming, we risk repeating the mistake of social networks: we gain immediate convenience, but lose our capacity for attention and critical thinking.

Agentic productivity is a powerful tool, but without constant human vigilance, it becomes a trap that consumes the very competence it was supposed to expand.

References

• https://0xsid.com/blog/agentic-coding-fatigue

• https://larsfaye.com/articles/agentic-coding-is-a-trap