Scollon argues that after months of daily LLM use he feels less curious, less satisfied, and more tired — not from overwork, but from the flatness of an accept-reject-accept-reject loop that replaced the compile-run-debug cycle. His point is that the shape of the work, not the tool's capability, is what's corrosive.
The editorial frames this as a mechanism problem rather than a quality complaint: LLMs replace the small hits of understanding that come from forming hypotheses and reading code with a duller reviewing loop. Over time this erodes the very habits that make senior engineers good at engineering.
A sizable group in the thread reported the same symptoms Scollon describes: poor retention of code they nominally 'wrote,' reluctance to read documentation, and shipping features they couldn't explain. Several named it as learned helplessness disguised as productivity gains.
One camp in the discussion rejected the burnout framing, arguing that developers feeling this way are using LLMs wrong. They frame the fatigue and dissatisfaction as a delegation and prompting skill gap rather than an inherent property of working with AI assistants.
Alec Scollon's post ‘I think I have LLM burnout' landed on the Hacker News front page and stuck there, pulling 294 points and a comment thread full of engineers saying some variation of ‘yeah, same.' The post isn't a screed against AI. Scollon uses the tools daily. His complaint is quieter and more interesting: after months of piping every problem through an LLM, he noticed he felt worse at his job, not better — less curious, less satisfied, and oddly more tired at the end of the day.
The burnout he describes isn't the classic overwork kind. It's the flatness that shows up when the interesting parts of the work get automated away and only the reviewing is left. You prompt, you skim, you paste, you fix the thing the model got wrong, you move on. Repeat for eight hours. The compile-run-debug loop that used to produce small hits of understanding gets replaced by a longer, duller loop of accept-reject-accept-reject.
The HN thread quickly split into two camps. One group pushed back — ‘skill issue, you're prompting wrong, learn to delegate.' The other group, larger and more specific, described the same symptoms: reduced retention of code they'd ‘written,' a creeping unwillingness to read documentation, and the strange sensation of finishing a feature without being able to explain how it works. A few called it what it probably is: a mild case of learned helplessness, dressed up in productivity clothing.
The interesting thing about Scollon's post isn't the diagnosis — plenty of people have written about AI making them feel dumb. It's the mechanism. He's not arguing that LLMs are bad at coding. He's arguing that the *shape* of working with them is corrosive to the parts of the job that make engineers good at engineering over time.
Consider what a senior developer's day used to look like. You'd hit a problem, form a hypothesis, read some code, form a better hypothesis, try something, watch it fail in an informative way, and eventually understand the system a little better than you did that morning. That loop is slow. It's also how expertise compounds. Every debugging session was a deposit into a mental model you'd draw on for years.
Now compare the LLM-mediated version. You describe the problem in English. The model produces a plausible answer. You paste it in. It works or it doesn't. If it doesn't, you paste the error back. Somewhere in there, the deposit-into-mental-model step got skipped. You solved the problem without learning the system. Do that for a quarter and you've shipped a lot of features and understood almost none of them.
The HN comments included a striking observation from a staff engineer at a large fintech: their team's velocity went up measurably after adopting Copilot and Cursor, but their on-call quality went down. Incidents took longer to resolve because the people paged had never really *read* the code they'd merged. The features worked. The mental models were hollow. That's the tax nobody's putting on the productivity dashboards.
There's also a motivational angle worth naming. A lot of engineers got into this work because solving hard problems feels good. If you route every hard problem to a model, you don't just lose the skill-building — you lose the dopamine that made the job sustainable in the first place. That's the actual ‘burnout' in Scollon's title. Not exhaustion. Anhedonia.
None of this is an argument for going back to writing every for-loop by hand. Nobody misses the parts of the job that LLMs are genuinely good at — boilerplate, unfamiliar-syntax lookups, one-off scripts, the fifth time you've written the same JSON parser. Handing those off is pure win. The problem is when ‘hand off the boring stuff' quietly becomes ‘hand off everything, including the parts that were teaching you something.'
The practical response isn't a policy. It's a habit. A few things that seem to work, based on Scollon's post and the more thoughtful HN replies:
Draw a line between typing help and thinking help. Autocomplete a function signature you already know? Fine. Ask the model to design the data model for a feature you don't understand yet? You just skipped the part of the job you were being paid to do. The distinction is: are you using the LLM to type faster, or to think less?
Read what you merge. Sounds obvious. It isn't anymore. If you can't explain a PR you're about to approve without re-prompting the model, you don't understand your own codebase, and future-you is going to pay for that at 3 a.m. A useful discipline: for anything non-trivial, close the LLM tab and re-derive the change in your head before hitting merge.
Keep at least one hard problem a week. Pick something — a gnarly bug, a performance question, a system design decision — and solve it the old way. No model. It'll feel slow and stupid at first. That's the muscle atrophying and then coming back. Engineers who do this report the burnout lifts within a couple of weeks, which is consistent with what the psychology literature says about learned helplessness: the treatment is agency, applied repeatedly.
Watch for the ‘I don't care' signal. The clearest symptom in the HN thread wasn't fatigue. It was indifference. If you notice you've stopped being curious about the systems you work on — stopped opening the source of the library you're using, stopped wondering why the query planner picked that index — that's the flatness Scollon is describing. It's an early warning, not a personality trait.
The LLM productivity story has been told entirely in terms of throughput: lines of code, PRs merged, features shipped. Scollon's post is the first widely-shared version of the other side of the ledger — what happens to the human doing the merging. The industry is going to have to develop some vocabulary for this, because ‘burnout' is close but not quite right, and ‘deskilling' is accurate but sounds like a labor economics paper. Whatever we end up calling it, the fix is probably the same: use the tools for the parts of the job that were never fun, and jealously guard the parts that were.
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 develop
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
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
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 hardco
Top 10 dev stories every morning at 8am UTC. AI-curated. Retro terminal HTML email.
I don't think I have a "burnout", but LLMs are really exhausting due to amount of pressure they generate. No one is really pushing me to increase my workload, but at every moment there is always something ready, done by my clankers or clankers of other people that I could be unblockin