991 senior devs upvoted 'I forgot how to think through code'

What happened

An anonymous senior engineer posted to bearblog under the title 'LLMs are eroding my software engineering career and I don't know what to do.' Within a day it hit 991 points on Hacker News with hundreds of comments, most of them some variation of 'same.' The post is short. The author has a job. He is not being replaced. He is describing something more uncomfortable: he can still ship, but he is no longer learning while he ships, and increasingly he cannot reconstruct why his code works without asking the model that wrote it.

This is a different complaint than the one HN normally rallies around. The story isn't unemployment, juniors-can't-get-hired, or 'AI replaced me' — it's a working, mid-career senior confessing that the cognitive substrate of his craft is dissolving while his paychecks keep clearing. That's a more interesting data point than the layoff threads, because it doesn't have a market explanation. Nobody is forcing this engineer to use Claude. He's using it because not using it is now slower than his peers, and slower than his peers is a worse review.

The 991 upvotes are not endorsement of his diagnosis. They're recognition. A lot of people read it and saw themselves.

Why it matters

Harry Braverman wrote 'Labor and Monopoly Capital' in 1974, coining the term 'deskilling' to describe what happened when industrial tooling subsumed the judgment of skilled craftsmen. The pattern has repeated, on roughly a 20-year cycle, every time a new layer of automation has reached cognitive work. Machinists in the 1980s. Bench accountants in the 1990s. Translators and transcriptionists in the 2010s. Customer service in the early 2020s. The arc is consistent: the tools start as augmentation, get good enough to do the load-bearing thinking, and the practitioners around them slowly lose the ability to do the work the old way — not because they're banned from it, but because the cost of doing it the old way is no longer justifiable.

Wages don't crater overnight in any of those fields. What craters is the autonomy of the median practitioner, the career trajectory that used to come from accumulated craft, and the floor of competence below which people get filtered out. Translation work didn't disappear — it shifted to post-editing machine output at lower rates, with the rare conference interpreter or literary specialist preserved as a luxury tier.

Software is the first profession to feel this with a $300K median for the affected tier, and the first one where the practitioners have enough discretionary income and platform reach to write about it in real time on Hacker News. That's most of what's novel here. The pattern is old. The audience is new, the comp is new, and the lack of any existing playbook is new. There is no software union. There is no licensure. There is no AMA-style guild structure that could declare a minimum standard of 'work an engineer should be able to do unassisted.' What there is, instead, is a deeply individualistic profession that built its identity around the idea that craft was rewarded — and is now finding out that craft, at the median, isn't being rewarded relative to throughput.

The HN comment section is unusually subdued. The top replies aren't disagreements. They're confessions in miniature: 'I used to read every line in a PR. Now I trust the diff because the tests pass.' 'I can't whiteboard the algorithms I used three years ago.' 'My PR velocity is up 40% and my understanding of the system is down by an amount I can't measure.' The comment thread is the first time in recent memory that HN, a forum congenitally allergic to admitting weakness, has read like a support group.

What this means for your stack

The individual playbook, in the absence of any collective one, has to be deliberate and slightly inconvenient. A few things that actually work, based on the HN comment threads and from talking to engineers who've thought about this:

First, protected practice time. Some teams are experimenting with 'no-autocomplete days' or weekend katas where the rule is no LLM, no Stack Overflow, just the docs and the compiler. This sounds twee until you try it and notice how much you've outsourced. The point isn't to reject the tool. It's to keep the muscle.

Second, audit your own code reviews. Are you reading the diff, or are you reading the summary and trusting the tests? If you can't articulate, in a hallway conversation, what the change actually does at the systems level, your review is a rubber stamp with extra steps. The compounding career risk isn't that LLMs will replace you — it's that you'll lose the ability to notice when they're wrong, which is the only durable skill left in the loop.

Third, specialize sideways. The work LLMs are bad at, today, isn't the algorithmic stuff — it's the parts of engineering that involve incomplete information and political context. Translating a vague PM ticket into a concrete spec. Debugging a system you didn't build, under time pressure, where the symptom doesn't match the cause. Architecture decisions that depend on org chart realities and three-year roadmaps. These are the parts of senior work the models cannot replicate, because they don't have the context. Lean into them.

The hiring market, for what it's worth, has not yet reacted to this. Interview loops still test the parts of the job that LLMs are good at — algorithmic puzzles, framework trivia, leetcode. The gap between 'ships fast with AI' and 'actually knows what they shipped' has not yet shown up as a hiring signal. It will. The first companies to filter for it will have a quiet advantage.

Looking ahead

The bearblog post will recede from the front page. The pattern won't. Software is now the case study other knowledge professions will read to figure out what their own deskilling response looks like, and the playbook is going to have to be invented by the people living through it. The author wrote 'I don't know what to do,' which is honest and probably the correct first move. The 991 upvotes mean a lot of working senior engineers don't either. What none of them are saying yet — but should — is that the answer isn't going to come from the tool vendors, from the AI labs, or from a HN consensus thread. It's going to come from individual engineers who decide, this quarter, what work they're going to do without help, and stick to it long enough to notice whether the muscle comes back.