You've heard this line before. It's a little smug, a little vague, and usually followed by nothing actionable. Let me try to make it concrete.
The Parts of Your Job AI Is Actually Taking
Not "programming" in the abstract — specific tasks:
- Boilerplate generation. Gone.
- Explaining what a regex does. Gone.
- Writing the first draft of a CRUD endpoint. Mostly gone.
- Googling a Stack Overflow answer and adapting it. Largely gone.
If a significant chunk of your daily work lives in that list, your role is changing. Not necessarily disappearing — but changing enough that doing the same thing you did three years ago isn't a stable position.
The Parts AI Is Genuinely Bad At
- Understanding why a requirement exists and whether it's the right one
- Knowing which parts of a legacy codebase are load-bearing and which
are cargo cult
- Debugging something that only fails in production under a specific
combination of conditions
- Deciding that the technically correct solution is wrong for this team
right now
- Reviewing AI-generated code for subtle security or correctness issues
Notice that last one. AI generates code that needs to be reviewed — and reviewing AI output well requires more domain depth than writing the equivalent code yourself. The output is fluent and plausible. The bugs are less obvious than the ones you'd write.
The Junior Developer Problem Nobody Talks About Enough
Here's the uncomfortable one.
Senior developers have intuition built from years of getting things wrong in low-stakes situations. Writing messy code, debugging it, refactoring it, watching it fail in production, fixing it — that loop is how expertise accumulates.
AI is absorbing a lot of that practice ground. Entry-level work that used to be the training layer is getting automated first.
Which raises an honest question: how does the next generation of senior developers get built? We don't have a good answer yet. The people confident that "it'll work out" are mostly people who already have the intuition they needed to develop the old way.
What Actually Matters Right Now
Three things worth your attention:
Get comfortable reading AI output critically, not gratefully. The default mode is to feel relieved when AI produces something that compiles and looks reasonable. That's the wrong mode. Treat it like a PR from a contractor you don't fully trust yet.
Double down on the judgment layer. Architecture decisions, requirement clarity, tradeoff reasoning, system-level thinking — these are harder to automate and increasingly where differentiated value lives. If you've been coasting at the implementation layer, this is the time to move up the stack.
Don't let AI atrophy your debugging skills. Debugging is one of the clearest signals of genuine understanding. If you've stopped doing it because AI handles it often enough, you're trading short-term speed for long-term fragility.
The developers who are anxious about AI are often the ones doing the most pattern-match implementation work. The ones who seem least worried tend to spend most of their time on problems where the answer isn't obvious — where the work is figuring out what the work actually is.
That's not a coincidence.
For a broader operational take on how teams are restructuring work around AI — including where human accountability has to stay explicit — this is worth reading.