I won’t have a job soon. Apparently.
There’s been a weird tone creeping into all my conversations lately.
Not loud panic. Not screaming. Just… a moderate, constant hum. The kind you notice when you stop and realise everyone around you is talking a bit faster than usual.
Friends ask how work’s going, but they don’t really mean it. Colleagues phrase things like questions that are actually stress tests. People who’ve been calm for years suddenly say things like, “So… how worried are you, actually?”
And it’s not just tech. Markets are wobbling. Numbers on screens are doing that thing where they drop and bounce and drop again. The price of gold has gone absolutely bananas, which historically means humans have collectively decided they do not trust anything anymore.
Gold only does that when people are scared.
Not rational scared.
Primal scared.
Cave-painting scared.
And in software, that fear has found a very specific shape.
“Is this… still a job?”
Nobody phrases it dramatically. That would be embarrassing.
Instead it comes out sideways.
“I’ve noticed fewer junior roles lately.”
“Are you using AI much?”
“Do you think it’s still worth learning to code?”
These are not technical questions. They’re career survival questions wearing hoodies.
Underneath all of them is the same thought:
Is this thing I’ve built my life around about to quietly disappear while I’m still paying off a laptop?
And look - it’s not helped by the constant drumbeat of predictions. Software engineering is always apparently six months away from being dead. If you’ve been in the industry long enough, you’ve heard this announcement so often it’s started to feel seasonal, like flu warnings or end-of-year performance reviews.
But this time it’s different, they say.
Because this time there’s AI.
I’ve already been obsolete once
The thing is, this isn’t even the first time I’ve been told my career was ending.
The last time this happened - or at least the last time it happened this loudly - it was app builders.
You might remember them. Or maybe you’ve successfully repressed the memory.
They were going to democratise software.
They were going to empower “regular business users”.
They were going to let anyone drag, drop, and click their way to software supremacy.
No developers required.
That was the pitch.
Somewhere around the early 2010s, every second demo involved a smiling product manager assembling an app on stage like it was IKEA furniture.
Look - a button.
Look - a form.
Look - an entire mobile application built in fifteen minutes while a developer quietly contemplated retraining as a barista.
They had friendly names. App builders. Visual builders. Low-code. No-code. Tools that promised software without software people.
And for a while, the panic was real.
Because the promise was always the same one we’re hearing now:
“Why would you need developers when the business can just build it themselves?”
What actually happened last time
Here’s what didn’t happen.
Developers did not disappear.
Software did not magically become simple.
Complex systems did not politely collapse into drag-and-drop rectangles.
What did happen was familiar.
These tools were great at simple things.
Internal tools.
Forms.
Dashboards.
Prototypes that looked convincing enough to get budget approval.
And then reality showed up.
Because the moment someone asked for:
- real integrations
- real security
- real performance
- real edge cases
- or anything involving “just one small exception”
…a developer was summoned. Usually urgently. Usually late.
The business-built apps either grew until they needed engineering help, or quietly died and were replaced by something “more robust”, which is management speak for “we’re hiring engineers again”.
The tools didn’t kill the profession.
They just changed the edges of it.
Which should sound extremely familiar right now.
The mistake we always make
The mistake we always make is pretending this is a purely technical question.
Every discussion about AI replacing developers eventually lands on the same argument:
“Is the technology good enough yet?”
Can it write code?
Can it debug?
Can it design systems?
Can it replace people?
But that’s only half the problem. The other half is people. And people are the reason software has never behaved the way the diagrams said it would.
Here’s the uncomfortable truth:
Even if AI-generated code was terrible - for example, didn’t compile, hallucinated APIs, confidently broke production - it still wouldn’t stop companies from trying to replace engineers with it.
Because leaders don’t adopt technology based on technical correctness. They adopt it based on optimism, pressure, and the haunting fear of being the last person at the table not “doing AI”.
So whether AI can replace programmers is only 50% of the equation.
Whether people believe it can is the other 50%.
And belief has a long, proud history of ignoring reality.
Like many things it's a spectrum
At one end of the spectrum, AI automates every technical job, the economy collapses, and it doesn’t matter what you studied because society has turned into a slow-moving apology.
At the other end, AI never improves beyond today, companies lose interest, and everything stays basically the same forever.
Neither of those is going to happen.
Reality, as always, is messier and more annoying.
The job survives, but stops looking like the job
My prediction is the job survives, but stops looking like the job.
What’s already happening - quietly, unevenly - is that AI is eating the boring parts of programming.
The loops.
The boilerplate.
The test scaffolding.
The documentation.
The deployment pipelines.
The code you never loved but had to write anyway.
Developers aren’t vanishing. They’re just typing less.
The job shifts toward:
- making architectural decisions
- translating vague human desires into something a system can survive
- debugging when the AI confidently claims it fixed the issue and absolutely did not
- understanding how large systems fail in ways nobody predicted
This is why the junior market feels strange. The traditional “learn syntax by suffering” path is shrinking, while the ability to reason about systems is becoming the actual work much earlier.
What we used to call “senior skills” are slowly turning into table stakes.
Coding isn’t the job anymore. It’s the literacy.
When people ask if it’s still worth learning to code, they’re usually asking the wrong question.
The real question is whether it’s still worth understanding how software works.
And the answer to that is yes - because everything else depends on it.
You can’t debug what you don’t understand.
You can’t supervise AI output if you don’t know when it’s lying politely.
You can’t make good decisions about systems you can’t read.
Typing code might become optional.
Understanding it will not.
Or the job disappears and comes back with a new name
Another possibility - maybe later down the track - is that the job disappears and reappears under a different name.
There’s a future where “software engineer” quietly stops being a title, not because the work is gone, but because it’s reorganised.
Instead of writing code, technical people:
- oversee AI systems
- investigate when those systems build the wrong thing
- design workflows that stop automation from amplifying mistakes
- explain to leadership why “just let the AI handle it” has again caused fire
Because even in a heavily automated world, decision-makers still want a human to tell them what to do. Accountability doesn’t scale as well as software does.
And the future - whatever else it is - is still extremely technical.
The uncomfortable, boring conclusion
If your dream was a career spent typing code by hand forever, untouched by automation, then yes - that’s probably a risky bet.
But if you’re comfortable adapting, learning, and doing work that sits around code rather than inside it, then no. It’s not too late.
The fear is understandable. When markets shake and gold spikes, everyone starts scanning the horizon for exits. Software people are no different.
But software has always been wrong.
The predictions have always been wrong.
And the job has always changed faster than the headlines admit.
If you feel unsettled, uncertain, and slightly behind no matter what you do - congratulations.
You’re not failing.
You’re just falling into the trap of thinking you are doing software wrong.
Exactly like the rest of us.