I had lunch with a friend last week who has been writing software professionally for eleven years. Staff-level at his last two companies. Has shipped systems that handle millions of requests a day. Can read an unfamiliar codebase and know where the bodies are buried within an afternoon.
He's been out of work for five months.
Not because he got laid off in a mass event. He wasn't. His company didn't do anything dramatic. He left on his own, in March, thinking he'd take six weeks off and then pick something up. He's had four onsites. All rejected.
I asked him what happened in the interviews. He said the same thing each time in different words: the conversations didn't go where he expected them to.
He's spent years learning how to explain complex systems. How to reason about tradeoffs. How to look at a piece of infrastructure and say "this will fall over in six months when traffic triples, here's why, here's what to change." That used to be the whole interview. You'd get asked to design something, you'd talk through the options, you'd land somewhere reasonable, done.
Now the first round is a screen with an AI copilot enabled. The question is some variation of "build this feature." The candidate who finishes fastest wins. The candidate who uses the tool fluently wins. My friend, who spent a decade earning the right to write code slowly and carefully, was slower than a mid-level developer who'd never worked on anything serious but knew every keyboard shortcut in Cursor.
He said it plainly: I've been doing this for eleven years and I couldn't keep up.
I've been thinking about that sentence all week.
What actually changed
The easy answer is that AI tools got good. Everyone knows that. The harder question is which skills got devalued, specifically, because that's what nobody wants to say out loud.
Ten years ago the value of a senior developer was concentrated in three things:
Deep debugging. The ability to look at a production incident and reason from symptoms to cause without needing to read code. This is a skill that takes years to build and it's the reason companies pay seniors a premium.
Systems thinking. The ability to look at a product and know how it should be structured, where the boundaries should be, which decisions are reversible and which are one-way doors. This is the thing that separates someone who can build a feature from someone who can build a product.
Pattern recall. Knowing the language, the framework, the libraries, the idioms. Being able to write a Redux reducer from memory, knowing the correct way to structure a reducer or a saga. The long tail of syntax and convention you accumulate.
The first two skills are still valuable. Deep debugging and systems thinking are genuinely better when a person has been through ten years of production incidents. AI doesn't replace the judgment that comes from having been on call for a payment system at 3am.
The third one is gone.
Not gone gone. But heavily devalued. Pattern recall was never the interesting part of being a senior, but it was the part that made you fast, and speed is what the current market rewards. A junior with good AI tooling can now scaffold a feature in the time a senior used to spend opening files. The senior still understands the feature better. But the feature exists in both timelines, and the one that exists faster is the one that gets shipped.
Why this is uncomfortable to talk about
Because the older developers don't want to admit that a skill they spent a decade on is now worth less than it was. And because everyone who points this out gets accused of being doom-merchant. And because the people doing the hiring have convinced themselves that "using AI well" is a skill, and it is, but it's a different skill than the one they used to hire for.
There's a version of this where the whole thing is fine. The senior adapts, learns the new tools, and leverages their judgment to get twice the output of a junior. That's the version everyone tells in public. And for a lot of seniors, that's what's happening.
But there's another version where the senior gets caught in a trap. Too senior to take a junior role. Too slow to compete for the senior role. Too expensive to justify against two mid-level developers using AI. That version exists too and nobody talks about it.
I've heard from three people in the last month who are in some version of that trap. All of them are between eight and fifteen years into their careers. None of them are bad developers. All of them are having a harder time getting hired than they expected to.
What the market actually wants now
I've been trying to figure this out honestly and I don't have a clean answer. But here's what I've observed.
Companies are hiring for three things right now, in this order:
Speed to ship. Someone who can take a feature description and turn it into working code. Fast. The fewer meetings, the better. The AI-assisted developer who finishes the ticket in an afternoon is worth more to the business than the careful senior who finishes it in three days and does it more correctly.
Breadth. A developer who can move across the stack because the AI can help them in whatever language they're working in that day. Language expertise is less important than the ability to pick up a new one in an afternoon with Claude as a co-pilot.
Judgment. Knowing what to build and what not to build. This is still the senior's edge, but it's the last thing interviewed for. Nobody asks the "should we build this at all" question until you're four rounds deep, and by then you've already been filtered out for not finishing the coding screen fast enough.
The order matters.
Speed first, breadth second, judgment third. It used to be the opposite. The senior developer's edge was in the third category, and everything about their career was optimized to prove it.
The honest part
Some of this is adaptation anxiety and some of it is real. Let me try to separate them.
Adaptation anxiety: The market is going through a shift and the people most affected by it are the ones who built their careers around the old shape of the work. Every generation goes through this. Cobol programmers went through it. Front-end developers went through it when jQuery died. This is what it feels like from inside a transition, and it's uncomfortable but it isn't new.
Real: The specific thing that made a mid-career developer valuable in the past. deep framework knowledge, pattern recall, the ability to write fluent code in your head is genuinely worth less today than it was two years ago. Not worthless. Worth less. And the loss of value is permanent, not cyclical. This isn't a bad market that will recover. This is the market finding a new equilibrium.
Both of those things are true and I think we need to hold both.
The thing I don't want to say
The developers who are struggling the most right now are the ones who've been coding the longest without needing to adapt. Not because they were lazy. Because they didn't have to. The market rewarded them for what they already knew, for ten or fifteen years, and now it doesn't reward the same thing anymore.
I know how that sounds. I know it reads as "the seniors were coasting." That's not what I mean. Deep expertise in a specific stack is a real thing, and it took years to build, and the fact that the market doesn't value it as much today doesn't mean it was wasted. It means the market changed.
The senior developer's job right now is the same as everyone else's: figure out what's still valuable and lean into it. Systems thinking, judgment, the ability to look at a design and know whether it's going to work. Those things haven't lost value. They might have actually gained value, in a world where anyone can produce code and few people can tell which code is worth keeping.
But the interview doesn't test for any of that yet. That's the trap. The skills that matter most are the last ones the interview process asks about.
What I'd want to ask
If you're a senior developer who's recently been through a hiring process, what was the actual gap? Was it that the interview tested the wrong things, or was it that you didn't have the new skills the interview was testing for?
Top comments (0)