I Think I Have LLM Burnout: The Fatigue of Repetitive AI Patterns

From my experience, there are mainly 3 burnout reasons.

1. Multi-tasking is the top one. I usually have to frequently switch between 3 to 5 agent windows which are on different things. It's extremely exhausting when each round takes a few minutes. Before coding agent era, I believe most developers had chance to spend 2+ hours focusing on one thing. Now coding agents have increased my spectrum on the tech stack, but the bandwidth to do deep work isn't increased.

2. Agents are good at getting things running without crash, but do not guarantee to produce correct code. This is quite different from human experts with fundamental knowledge.

3. I also get frustrated when reviewing piles of AI generated low quality PRs. My attention is a limited resource. I don't waste too much energy on other people's work, but if I don't spend more effort, the entire project is corrupted quickly by reckless AI generated code without human author's careful thoughts and designs. Working with people who have less due diligence in mind is painful, working with them in coding agent era is 10x painful because they produce 10x shit. It's a team culture challenge that cannot be easily enforced.

I've started feeling slightly physically ill when I read Opus output for hours straight. This article rings very true for me. I've started complaining about it with my team; at least have a personal style guide in your agent rules that eliminates emdashes, the "it's not X, it's Y"s, the long lists of modifiers before the noun, using the word "land" to mean finish, etc. I hope this is just a phase of adolescent LLMs.

I’m currently doing a project with someone who only uses LLMs, and it’s exhausting and mentally draining.

Whenever I give feedback on something, the answer is just “let me tell Claude”. The person has no understanding of how everything works, and most of the code reflects that.

The other day he hardcoded in a demo mode, simply because he didn’t even know how to set up a local environment and set environment variables. I’m confused as to why Claude didn’t even knew this, but it might just be the prompting.

I limit LLM usage myself, and if I do use it, I try to use it on extremely specific tasks. It’s the only way it works for me.

I honestly don’t understand how all these companies are getting away with generating AI code. Even in a small project I quickly fall behind on my understanding of the project.

I do not have the burnout but I certainly operate similarly to the author. I continue to be unable to establish a workflow where allowing the LLM to generate code that I review is faster than writing the code myself. Literally the only two ways out of this dilemma is to blindly trust what was generated or to generate an uncharacteristically exhaustive suite of unit tests to validate every possible scenario. I just write the business logic myself and have the LLM do a lot of the rest. Boilerplate falls into the latter as well.

I am feeling very tired. Since I’ve started working with LLMs my output as a solo dev has easily gone up 20x. I’m closing client projects including ones that previously would have been far too ambitious to take on alone. Long running codebases are getting features that have dragged out for months or been sitting in the planning stages for even longer. And overall quality is way up now with more complete (and honestly better) test coverage.

I’m building personal projects at a prodigious pace. In a role reversal I treat the agents like I’m one of my clients (albeit a more technical one who gives them architectural direction) and they are me. I’m using the apps and tooling they make every day. I’ve cancelled SaaS subs for tools I’ve built myself.

I watch the tool calls and realize I should be better at core command line tools so I have a study plan to catch up (just a little bit a day). I’m revisiting long standing config that I dropped in to vim and tmux way back when I started and didn’t know anything.

I guess in theory I could hold my productivity to previous levels and read more. But it doesn’t feel like that’s possible. It feels like we are in one of those sea changes where the promise is less work, but the reality is increased productivity and expectations (the Industrial Revolution feels like the right parallel to reach for). Increased expectations happen in small ways and large. The agents are so good at polishing data presentations that I always send cleaned up visually […]

The reason I'm getting LLM burnout is from dealing with the obvious neutering and opaque downgrading of all the top models.

Prior to the last 12mos AI companies were hell bent on squeezing out the best results from mediocre models.

But... now that the top models have progressed, those same AI companies have switched their efforts into reducing the computation (cost of a producing a result) as much as possible without being too obvious.

What was an exponential slope in the quality of results over the last 36 months has now nearly flat lined.

Addendum: IMHO results have 'flat lined' not because the models aren't much more capable than a year ago, but because conserving the enormous processing cost (of an over subscribed user base) supersedes the goal of following the user's explicit instructions (e.g. especially if that means more processing cost) to generate the best results.

It sounds kind of like being stuck working with coworkers who--while not overtly hostile--need constant hand-holding and repeat the same kinds of mistakes every day and can't even be genuinely sorry about it.

Just because we work with computers doesn't mean we don't take, er, social-damage. Or perhaps parasocial damage, in this case.

This is legitimately the reason I'm looking to leave programming.

I got into programming because the problems of programming were interesting to me. But if the problems go from "figure out why this calculator is off by one in France" to "Get this LLM to stop spamming cutsey emojis", then maybe it's time for a career change.

I don't really understand how this isn't a self-inflicted problem? Perhaps it's because I'm not really mandated to use LLMs in a particular way, but I've had great success doing a combination of writing code myself and using smaller but faster models as a sort of "flood fill". The larger models can also be useful when you're implementing something which already exists in similar form in the codebase, because you can just put that code in the context and you'll get something very similar outputted. So the more code you write, the better the LLM can be later on. Codebases should get easier to add to the bigger they get, not harder.

Of course if you're supposed to achieve so much output that it's not possible to do anything but vibe it, fair enough.