Software engineers all over the world are going through grief, real unvarnished loss.

See for yourself.

Denial

Denial looks like the “AI can’t really code” phase that dominated 2023 and much of 2024. The reflex was to point at hallucinations, broken outputs, toy examples, and conclude the threat was overblown.

There’s still a residual version of this — devs who tried Copilot once in 2023, hit a bad suggestion, and concluded the whole category is hype. The METR finding actually gets weaponized here: “See, AI makes devs slower.” That’s a real result. But using it to dismiss the broader trajectory is denial doing its work.

Anger

Anger is the loudest stage right now and the most visible online. It’s the resentment toward executives pushing AI for cost-cutting, the cynicism about “AI babysitter” roles, the fury at Shopify-style mandates to prove AI can’t do something before hiring a human, the contempt for “vibe coders” flooding GitHub with insecure slop.

Some of this anger is legitimate critique. Some is grief wearing a critic’s costume. The tell is when the intensity outruns the argument — when someone isn’t just saying “this code is bad” but “this shouldn’t be allowed to exist.” That’s identity defense, not technical analysis.

Bargaining

Bargaining is where I think a huge chunk of the profession actually is right now, and it’s the most interesting stage. It looks like:

  • “If I just become a prompt engineer, I’ll be safe.”
  • “If I specialize in AI orchestration, I’ll be the one directing the agents.”
  • “If I get really good at the parts AI is bad at — architecture, taste, judgment — then I’ll be untouchable.”

The fifth-year master’s degrees Stanford grads are doing? Bargaining. The frantic pivot to “AI engineering” job titles? Bargaining. The reframe to “I’m an Architect of Intent now”? Often bargaining dressed as acceptance.

Some of these moves are genuinely smart adaptations. But the emotional engine underneath is often still “if I do X, the old deal comes back.” The old deal isn’t coming back.

Depression

Depression is the quieter stage and probably the most underreported, because it doesn’t generate hot takes. It’s the senior dev who’s been shipping code for fifteen years and suddenly feels the work has gone hollow. The mid-career engineer who realizes their hard-won expertise in a specific framework is being commoditized in real time. The junior who graduated from a top CS program and is on month six of applications.

This is where the Anthropic engineers’ comments about losing the “emotional” satisfaction of low-level work live. It’s not clinical depression necessarily. It’s the grief of watching a craft you loved become something else — or finding that being a “fleet manager of agents” doesn’t scratch the itch that being a builder did.

Acceptance

Acceptance is rarer and quieter still, and it’s worth distinguishing from resignation.

Resignation says “fine, I’ll just do whatever, it doesn’t matter.” Acceptance says “the deal has changed, the new deal has different rules, and I can find meaning inside the new deal.”

The reframe is an identity play. That the identity was never “person who writes code” but “person who solves problems with software” is acceptance. Not because it makes the change painless, but because it locates something stable underneath the thing that’s being lost. The devs who seem most okay are the ones who’ve genuinely metabolized that the product was always the goal and the typing was always incidental.

Juniors and seniors are grieving different things

Seniors are grieving the loss of craft and identity — the felt sense of what the work was. Juniors are grieving something more like a stolen future: the career path that was supposed to exist and doesn’t, the apprenticeship rungs that have been sawed off.

Both are real. They’re not the same loss.

Grief without distance

There’s a structural reason this grief is harder than most: the thing causing the loss is also the thing devs are being asked to embrace, daily, in their workflow.

You can’t avoid AI coding tools while working as a dev in 2026. So the grief doesn’t have a clean “before and after.” You’re using the thing that’s killing the old version of your job and identity, every day — and often it does feel helpful, which complicates the anger.

It’s grief without distance.

A sixth stage: finding meaning

Some have added a sixth stage to the Kübler-Ross model: finding meaning. It’s probably the most important one for this case, actually. Because acceptance alone can be thin. “The job is different now, deal with it” might be true, but it’s cold.

The devs who seem to be thriving aren’t just accepting the change. They’re finding that the new shape of the work lets them do things they couldn’t before: ship products solo, work across stacks they’d never have touched, build the ambitious thing they’d been deferring.

That’s not denial of the loss. It’s the loss plus a new thing growing in the space it left behind.

A caveat

Not every dev needs to grieve. Some genuinely do find the new workflows better and aren’t suppressing anything. The grief frame illuminates a lot, but it can also pathologize people who’ve just… adapted, without much drama.

But for the people who are clearly struggling — and lived experience suggests that’s a significant slice — “you’re grieving an identity, and it’s a real loss, and there are stages to it” is probably more honest, and more helpful, than “you have AI anxiety, here are five productivity tips.”