If you've been in this industry for more than a couple of years, you've been told at least three times that your job is about to not exist. Some new thing is going to come along and make developers obsolete, or at the very least make whatever you spent the last two years learning completely irrelevant. And every single time, the people screaming loudest about the revolution are either selling something or haven't shipped production code since the Obama administration.
And yet, here we are again.
We've Seen This Movie Before
I started with web development in the React era, which means I got a front-row seat to the JavaScript framework wars. Angular was king, then React showed up and suddenly Angular was legacy. Then Vue was going to kill React. Then Svelte was going to kill everything. But wait, you should use Astro instead! Then React Server Components dropped and half the React community declared React dead, which is a fun thing to say about the most widely used frontend framework on the planet. Through all of that, people were shipping software. The frameworks changed; the work required didn't.
Then there was the cloud migration panic. "Ops is dead," they said. "You won't need infrastructure people anymore. Just throw it on AWS." Fast forward a few years and DevOps is one of the hottest career paths in tech, cloud bills are a line item that makes CFOs cry, and half the industry is hiring platform engineers to wrangle the exact infrastructure that was supposed to manage itself.
Docker was going to simplify everything. Then Kubernetes was going to simplify Docker. If you've ever written a Helm chart, you know how that turned out. Genuinely transformative technology, absolutely. But "just containerize it" became the new "just rewrite it in Rust" for a while there.
And of course, no-code. Low-code. The tools that were going to let your product manager build the whole app themselves. Which, to be fair, they kind of can now, right up until they need authentication, or error handling, or anything that touches a database in a way that doesn't make a security engineer lose sleep. No-code is great. It also didn't replace a single developer I know.
Every one of these technologies delivered real value. Every one of them was also wildly oversold by people with conference talks to give and newsletters to grow. The pattern is so consistent at this point that recognizing it is basically a professional skill.
The Playbook Never Changes
Here's how it goes, every time, without fail:
- New technology emerges that genuinely solves a real problem.
- Early adopters start using it and get real benefits.
- Evangelists discover it and start giving talks with titles like "X is Dead, Long Live Y."
- Thought leaders on Twitter declare that anyone not using it is a dinosaur.
- Skeptics push back, often too hard, dismissing the whole thing as hype.
- Reality settles in. The technology finds its place. It's neither the revolution nor the fraud. It's a tool.
- Everyone moves on to panicking about the next thing.
The engineers who do well through these cycles aren't the ones who jump on every bandwagon, and they're not the ones who refuse to learn anything new out of principle. They're the ones who adopt early enough to benefit but stay skeptical enough to avoid rewriting their production stack based on a blog post and a conference keynote.
That's the actual skill. Not picking winners. Not being right about what's hype and what's real. It's holding both of those things in your head at the same time and making reasonable decisions anyway.
So Yeah, I Use AI Now
I'll be honest: when GitHub Copilot first showed up, I thought it was a fancy autocomplete that would occasionally save me from typing a for loop. And for a while, that's kind of what it was. Neat, not transformative.
But things moved fast. I've been using Claude Code as a core part of my workflow for a while now, and it's a different animal entirely. It's not just basic autocomplete anymore, it is more along the lines of having a junior developer who never sleeps, never gets annoyed when you ask it to refactor the same function for the fourth time, and occasionally suggests something genuinely clever that you wouldn't have thought of.
It's also a junior developer who will confidently write code that doesn't compile, hallucinate an API that doesn't exist, and occasionally solve the wrong problem with impressive efficiency. So, you know. Like a real junior developer in that way too.
Here's what it's actually good at in my day-to-day: scaffolding boilerplate, exploring unfamiliar codebases, generating test cases, rubber-ducking architecture decisions, and handling the kind of repetitive refactoring work that makes you question your career choices. It's a force multiplier. A genuinely significant one.
Here's what it's not good at: knowing your business domain, understanding why a system was built the way it was, making judgment calls about tradeoffs that require context it doesn't have, or replacing the part of your brain that says "wait, this feels wrong." That part is still your job. If anything, it's more your job now, because the speed at which you can generate code means the speed at which you can generate problems has also increased proportionally.
I don't trust it blindly. I review everything it produces with the same scrutiny I'd give a pull request from anyone else on my team. Sometimes more, because it doesn't push back when I ask "are you sure about this?" It just says yes. That's not confidence, that's compliance.
But I also don't pretend it's not useful. That would be like refusing to use Google because sometimes the search results are wrong. The tool has limitations. The tool is also incredibly powerful. Both of those things are true at the same time, and being able to hold that duality is, I'd argue, the whole game.
Skepticism Is the Skill
There's this weird false dichotomy in the discourse right now. Either you're an AI true believer who thinks we're six months from AGI and developers are going to be obsolete by Christmas, or you're a skeptic who thinks the whole thing is a bubble and these tools are just spicy autocomplete. Both camps are wrong, and they're wrong in the same way: they've picked a position and stopped thinking.
The reality is messier and more interesting. AI coding tools are genuinely useful right now, today, in production, for real work. They're also overhyped, frequently unreliable, and surrounded by an ecosystem of influencers and startups making claims that range from optimistic to delusional. Holding both of those truths simultaneously, taking action based on that understanding, is just good engineering judgment.
This has always been the job. The best engineers I've worked with weren't the ones who adopted every new tool immediately, and they weren't the ones who stuck with jQuery until 2024 out of spite. They were the ones who could look at something new, understand what it was actually good at versus what the marketing said it was good at, and make a pragmatic call about whether and how to integrate it into their work.
Being skeptical about AI doesn't mean ignoring it. It means using it with your eyes open. It means understanding that when someone tells you AI is going to replace developers, they're selling the same story that's been sold about every major technology shift for the last twenty years. And it means understanding that when someone tells you AI is useless hype, they're making the same mistake as the people who said the cloud was just "someone else's computer" and therefore not worth thinking about.
The Ocean Is There Whether You Acknowledge It or Not
Software engineering as a career has always been about riding the line between "this changes everything" and "this changes nothing." The answer, boringly, is always somewhere in the middle. AI is not going to replace you. AI is also not a toy. It's a tool, and like every tool before it, its value depends entirely on the judgment of the person using it.
I've added AI to my workflow not because I think it's the future of everything, but because right now, today, it is a force multiplier for my work. If that stops being true, I'll stop using it. I'm not loyal to the technology, I'm loyal to getting things done.
The sky isn't falling. It never was. But the weather is changing, and the engineers who pretend otherwise are going to get wet. Bring an umbrella, keep your bullshit detector charged, and ship your code. That's always been the job. It still is.