Agents Are Supposed to Help, So Why Are We More Exhausted?

Posted on In 评论: Views:

I haven't updated my blog in over a year. Not out of laziness, nor because I've fallen behind on technology. It's more of a conviction: once AI became powerful enough, the value of technical blogs dropped significantly. People shifted from searching and reading to learning through direct conversations with AI. On top of that, AI-generated content floods social media the moment anything happens, making me feel there's little point in writing after the fact. Blog traffic has plummeted over the past year, which further killed my motivation to spend hours crafting a post. I miss the days when every article was painstakingly typed out, word by word, over hours or even days.

AI tools have made remarkable progress in the past six months. As a heavy user, I want to talk about this: if agents are supposed to be our helpers, why do we feel more exhausted than ever?

The Current Workflow

Agents are now involved in every stage of a feature, from start to finish. Feasibility research? Let the agent do a first pass. Technical design? Let it draft a proposal. Implementation? Let it write the code. Testing? Let it fill in the gaps. You're still present at every step, but your role has changed, from doing the work yourself to reviewing proposals, reviewing code, and reviewing tests. You used to walk the entire pipeline yourself: write, debug, test, deploy. It was slower, but you knew every detail of the system. Now you review what the agent produces. Efficiency is up, but at the end of the day, you're more tired than before.

Managing Several "Unreliable Junior Devs" Solo

This is the heart of the exhaustion: you're managing multiple agent tasks in parallel. Session A is working on Feature A, Session B on Feature B, Session C is running tests. When A finishes, you switch over to review it. Just as you figure out why it made certain choices, B is done too. Every context switch forces you to rebuild mental context, and it's someone else's code, which is far more draining than switching between your own.

The real kicker is that these "junior devs" are blazingly fast. What a real junior might take a day or even days to finish, the agent delivers in minutes. You haven't finished reviewing the last output before the next one lands. With actual juniors, you can control the pace, tell them "no rush, deal with it tomorrow." Agents don't wait. They just keep producing, and you're constantly pushed forward, review this, then review that, there's always something waiting. You're not using the tool; the tool is driving you.

The Difficulty of Review and Verification

There's an old saying: there are two kinds of code in the world. Code that is obviously free of bugs, and code with no obvious bugs. What agents produce is almost always the latter.

Here lies a fundamental paradox: you use agents to boost efficiency, but ensuring their output is correct demands substantial review time. The more thoroughly you review, the safer you are, but the smaller your efficiency gains. The looser your oversight, the higher your efficiency, but the greater the risk of problems. And the issues often aren't simple hallucinations; they stem from top-level design: whether the architectural choices are sound, whether the abstraction layers are right, whether the boundaries with existing systems are clear. Tests may not catch these things. Only humans can judge.

The Workload Has Grown

Agents can write anything, and your boss knows it. So work that never belonged to you starts landing on your plate. Backend developers used to just do backend; there were separate people for frontend and data. Now your boss figures that with agent assistance, tweaking a frontend component shouldn't be a big deal, right? Adjusting a data pipeline should be doable too, right? None of these areas are entirely foreign to you, but you're not exactly an expert either. You still have to review what the agent produces, but with less confidence. Before, you could say "that's not my domain." Now the agent has accepted the work on your behalf, and you can't push it away.

The Never-Ending Tool Chain

Then there are the tools themselves. Over the past year, Cursor evolved from tab completion to background agents. Claude Code went from barely usable to running entire features. MCP servers sprouted everywhere. OpenAI, Google, and other giants keep releasing new models, while startups ship something new every week. Articles like "Tool X completely transformed my workflow" flood group chats constantly. You feel uneasy not trying them, but after trying, you find they're nothing special.

The methodology keeps shifting too. From the early days of Prompt Engineering to today's Harness Engineering: how to write Skills, how to feed context, how to orchestrate multi-agent setups, when to use Plan mode… None of this has a definitive answer, and today's best practices might be obsolete tomorrow. You used to stick with one IDE for three to five years; now the tool chain turns over every three to five months. Sometimes I wonder whether the energy spent learning these wheels and building these wheels has already exceeded the efficiency gains the wheels themselves provide.

Growth Has Slowed

Everything above is about the present exhaustion. There's also a longer-term concern: daily learning has decreased. Implementing a feature used to mean reading documentation, digging through source code, and understanding the underlying principles. Now agents hand you results directly. The work gets done, but the incidental learning that used to come with it is gone. You used to take a feature from research to launch entirely on your own. That feeling of "I fully understand this thing" after shipping was deeply reassuring. That sense of complete mastery is increasingly rare. Daily output is rising, but growth is slowing.

So back to the opening question: why are we more exhausted? Endless code to review, work you can't turn down, tools you can't keep up with, a pace that never lets up, plus the creeping loss of control over your own growth. Agents genuinely boost efficiency, but these costs are equally real.

You thought you hired an assistant. Turns out you got several unreliable reports who need your constant supervision. And they never clock out.