I’ve worked with developers for years. Lots of them. Brilliant ones. The kind of folks who can stare at a screen for six hours, emerge blinking into daylight, and casually say something like, “Yeah, I just refactored the entire data layer,” as if they’d popped out to buy milk.
And here’s the thing.
Only a small percentage ever looked up.
Not because they couldn’t. Because they didn’t need to. The world rewarded heads-down brilliance. If you could go deep, stay focused, and produce clean, elegant code, you were valuable. Extremely valuable. Possibly the kind of valuable where someone in a meeting says your name in a slightly reverent tone, like you are both a person and a rare species of orchid.
But something has shifted.
First, a small disturbance in the force
We’re entering this slightly strange era of what people are calling “vibe coding.” Which sounds like something you’d do at a beach festival, but is actually about building software by describing what you want rather than manually stitching every piece together.
You don’t just write code anymore.
You shape intent.
And suddenly, the value is drifting.
Away from:
sitting in the weeds
polishing the internals
perfecting the invisible
And toward:
understanding the problem
having taste
knowing what should be built
The developers who always had that broader view? The ones who could zoom out, talk to users, spot patterns, and say, “Hang on, we’re solving the wrong problem”?
They were always valuable.
That hasn’t changed.
What’s changed is… they might now be the default expectation.
Here is the bit that keeps nagging at me
For years, being a great developer often meant being able to tune out the noise.
To go deep.
To focus.
To care about the craft for its own sake.
There’s something almost monastic about it. A quiet satisfaction in getting things just right. The elegance of a well-structured function. The small joy of deleting 200 lines of code and replacing it with 20 better ones.
That’s not a flaw.
That’s the job.
But what happens when machines get very, very good at that bit?
Not perfect. Not magical. But good enough that the economic centre of gravity moves elsewhere.
Suddenly, the skill that once let you disappear into the work…
becomes the thing that leaves you exposed.
Because you can’t hide there anymore.
The cubicle walls are getting shorter
There used to be a safe place for developers.
A place where:
requirements came in (often slightly wrong)
you translated them into code (often slightly right)
and everyone was just relieved it worked
You could stay in that loop for years. Happily. Productively. Respectably.
That space is getting smaller.
Not gone. But smaller.
Because now:
the first draft can be generated
the boilerplate can be handled
the scaffolding appears almost instantly
And that means the questions shift.
Not “Can you build this?”
But “Should this exist?”
Not “How do we implement it?”
But “Is this what people actually want?”
Those are harder questions.
And they require looking up.
It turns out taste is annoyingly important
This is the bit that feels new.
Taste used to be a nice-to-have. A bonus. Something you picked up along the way if you happened to care about users, design, or outcomes.
Now it’s creeping into the core skillset.
Because when the cost of building drops, the cost of building the wrong thing goes up.
And the developers who thrive in that world are the ones who can:
sense what matters
cut through noise
understand real use cases
and say “no” more often than “yes”
That’s not a different profession.
But it is a different posture.
So where exactly does the code goblin go now
This is the bit I worry about.
Because the ability to go deep, to care about detail, to find beauty in the craft… that’s not going away. And it shouldn’t. It’s still essential.
But it might not be sufficient on its own anymore.
So where do those developers go?
Do they:
move up into product thinking?
stay deep but become specialists in harder, more complex systems?
become the folks who shape the tools the rest of us use?
Probably all of the above.
But it’s a shift. And shifts are uncomfortable.
Especially when they touch identity.
A slightly hopeful ending
If I’m honest, the developers I’ve always admired most were never just heads-down.
They had range.
They could dive deep when needed…
but they could also surface, look around, and ask better questions than anyone else in the room.
They understood people. Not just systems.
And they cared about outcomes. Not just outputs.
Those folks are going to be fine.
More than fine.
But still
I do worry about my developer friends.
Not because they aren’t talented.
But because the game is changing in a way that quietly removes the place they’ve been most comfortable.
And when that place shrinks, you have to step out.
Look up.
Engage.
Decide what actually matters.
Which, if we’re honest, was always where the real value lived anyway.
Leave a Reply