“Have I gone mad?” asked the Senior Developer.
“I’m afraid so,” said the AI. “You’re thinking about using me.”
And that, dear reader, is where the trouble starts.
Because if you want to understand why senior developers bristle, recoil, scoff, or pretend not to hear when AI is mentioned, you must first understand what a senior developer actually is.
They’re not just workers. They’re hatters.
They make their own hats. Stitch by stitch. Scar by scar. Some design them carefully. Others earn them by surviving systems that tried very hard to kill them. Either way, no one hands you a senior hat. You don’t buy it off the rack. You emerge one day already wearing it, slightly singed, brim bent out of shape, wondering what just happened.
There are people in this story who sit beyond the senior developer.
They’re not defined by a single hat.
Their coats come later.
For now, we’re talking about hatters.
The Hat Is the Identity
Junior developers don’t hate AI. Non developers don’t hate AI. Product managers love AI in the way one loves a very sharp knife that someone else will be holding.
It’s admiration without responsibility. Awe without blood on the hands.
Like the person at a dinner party who waxes lyrical about sushi chefs: “such precision, such calm, such artistry!”. They lean forward, eyes wide, enchanted by the blade flashing inches from human fingers.
They do not, however, want to be the one holding the knife.
They’re not thinking about the decades of muscle memory. The cuts you don’t see. The pressure of knowing that one slip ruins the fish, the dish, the service, the night. They’re enjoying the performance, not the weight of consequence.
Or take the racing driver. Everyone loves Formula 1. The speed. The bravery. The poetry of control at 200mph. Very few people lie awake at night thinking about what it feels like to misjudge a corner, when carbon fibre and physics are about to have a loud disagreement.
Or the air traffic controller. Invisible when everything goes well and instantly blamed when it doesn’t. Responsible for thousands of lives moving through the sky, while everyone else just enjoys the view out the window.
No one asks if they enjoyed the responsibility. No one applauds the nights spent replaying decisions that went fine, but could very easily have gone another way.
Product managers admire the output. The velocity. The promise of progress.
Senior developers live with the consequences.
And senior developers have been wearing a particular hat for a very long time.
That hat says: I know why this breaks.
Not how. How is for manuals. But why. The invisible causes. The ghost in the machine. The reason this bug only appears on Tuesdays, during a blood moon when the cache hasn’t quite warmed up.
That knowledge wasn’t learned. It was earned. Slowly. Painfully. Repeatedly.
Now along comes an AI. Plonks itself at the table. Pours the tea. And says:
“Oh, that? Yes, that’s a race condition caused by a stale closure.”
And the hatter feels something tighten under the brim.
Because if the machine can say the words, what happens to the hat?
The Offence of Effortlessness
AI doesn’t struggle convincingly and that’s a deeply underappreciated problem.
Senior developers trust things that look like they’ve suffered. Tools that require configuration files. Compilers that yell at you. Documentation that hasn’t been updated since v0.1.
AI, on the other hand, breezes in like a chess prodigy who learned the game five minutes ago, then apologises for not being very good yet.
It’s unsettling.
Not because it’s wrong. But because it didn’t pay the price.
In senior developer culture, price is everything. Effort is currency. Pain is proof of legitimacy. Anything that skips the pain must, by definition, be cheating.
AI feels like turning up to a marathon on a bike, then asking why everyone’s sweaty.
The hatters glare. Not out of cruelty. Out of confusion.
The Fear That Isn’t About Jobs (But Absolutely Is)
Ask a senior developer if they’re worried about losing their job to AI and they’ll scoff, adjust their hat, and say something like:
“No, obviously not. It can’t reason about systems.”
Which is true.
And also not the point.
The real fear is subtler. More existential. Harder to admit without spilling tea everywhere.
Senior developers are often valuable not because they type fast, but because they decide what not to type. They prevent disasters that never appear in GitHub issues. They delete code instead of adding it. They say no in rooms where everyone else is nodding.
AI threatens to flood the world with plausible code.
And plausible code is dangerous. It looks right. And then it drops your database.
Because once the table fills with enough of it, the senior’s role shifts. From builder, to editor of infinite suggestions. From creator, to curator. From author, to reviewer of a never ending book they didn’t ask to read.
That feels like demotion, even if the title stays the same and the hat still fits.
The Control Illusion (Now With Extra Chaos)
Senior developers have made peace with chaos. They’ve catalogued it. Named it. Put guardrails around it. They know exactly which parts of the system are terrifying, and which only look scary.
AI reintroduces chaos. But without context.
It happily suggests patterns that are technically valid and strategically disastrous. It optimises the local, while quietly burning down the global. It does exactly what you asked, not what you meant, then looks at you proudly, like a clever dog that brought you a live squirrel.
To a junior, this is magic. To a senior, it’s just another thing they are now responsible for.
And hatters already carry enough.
Why Juniors Are Fine With It
Juniors don’t have hats yet. They’re still looking for the coat rack.
To them, the compiler isn’t helpful. It’s an enemy that needs to be beaten. It gives cryptic error messages that require experience to decode. It constantly rejects them.
AI doesn’t threaten their identity. It answers questions they were afraid to ask. It shortens feedback loops. It removes some of the suffering that once meant learning.
They haven’t yet developed the Stockholm Syndrome that the hatters call “experience”, and they’re not mourning the loss of the struggle.
Only hatters sit at the intersection of craft, status, and scar tissue. Only hatters hear AI and think:
If this works, what was all that for?
The Uncomfortable Truth (Refill Your Cup)
This is the bit that tends to make hatters shift in their seat. Not storm out. Not throw the tea. Just… adjust the brim slightly.
Because the uncomfortable truth isn’t that AI is coming for senior developers.
It’s that the hat was never meant to do all that work on its own.
The hat matters. Of course it does. You don’t throw it around. You don’t let just anyone wear it. You look after it, because it represents time, mistakes, and a lot of learning you’d rather not repeat.
But protecting it as if it’s the only thing that gives you value is where things start to go wrong.
AI doesn’t diminish the hat by existing. It just doesn’t treat it as sacred. It treats it like one input among many. A useful one. A powerful one. Just not the only voice worth listening to.
And that’s the part that feels uncomfortable.
Because somewhere along the way, the hat stopped being a tool and quietly became identity. Proof that the years mattered and the pain counted.
The reality is simpler, and slightly less romantic.
What mattered was what you picked up while making the hat. Judgment. Taste. Knowing when to stop. Knowing when not to be clever.
Those things work perfectly well alongside other hats. Other hatters. Even tools that turn up already wearing one.
The hat isn’t under threat.
Only the idea that it has to stand on its own.
And once you accept that, you begin to realise something else.
If the hat isn’t the thing that matters, then neither is defending it.
What matters is the head underneath it. The ability to think clearly in messy spaces. To reason, to judge, to decide when not to act.
AI doesn’t remove that role but it does have a habit of exposing it.
Which is uncomfortable. But also clarifying.
Because now there’s nowhere to hide behind clever syntax or heroic debugging stories. The question becomes simpler, and harder.
Do you know what you’re doing?
The Patchwork Coat
This is where a different kind of figure re-enters the room.
Not more senior in title, necessarily. But more senior in exposure.
These are people who have worn many hats already. And taken them off again. Their identity is no longer bound to any single one. It’s stitched together from many systems, many teams, many failures. They wear patchwork coats because they’ve outlived several hats already.
Which is why they’re often calmer about AI and more ready to accept it.
When AI arrives wearing an unearned hat, they don’t feel personally threatened. They’ve seen hats come and go. Frameworks arrive confident and fade into history. Methodologies declare themselves inevitable. Tools promise revolutions. The coat absorbs it all.
Senior developers feel the insult because the hat is personal. It’s their identity. It’s proof that the pain meant something.
Those with patchwork coats are less offended. They’re busy asking a different question.
Where does this fit?
Not whether the hat is deserved. Not whether the tool suffered enough. But whether it earns a square on the coat.
And here’s the invitation: For hatters to become something else.
Not to ditch that hat, but to loosen their grip on it. To realise that identity doesn’t have to be singular to be meaningful. That wisdom survives even when the tools change.
If you do know what you’re doing.
Drink up.
The tea is only getting stronger.
“If you don’t know where you’re going, any code will get you there.”
And remember, all the best people are mad.