I've been mentoring junior developers for years. It's one of the most rewarding parts of my job. Watching someone go from "I don't know how to write a for loop" to "I just shipped a feature that thousands of people use" is incredible.
Real Developer, Real Problems: The Death of the Junior Role?
But something's changed in the last year. The juniors I'm mentoring now aren't struggling with the same things. They're not asking "how do I write a reducer?" They're asking "is this AI-generated code correct?"
And I'm spending less time teaching them to write code, and more time teaching them to review AI-generated code. Which raises a question: if juniors aren't writing code, what are they learning? And if I'm not writing code either, what makes me "senior"?
This is my attempt to figure out what mentorship looks like in an AI-first world.
Here's what a typical day looks like now:
A junior developer comes to me with a feature. They've used Copilot (or Cursor, or Xcode's built-in AI) to generate the code. It looks reasonable. It compiles. But something feels off.
I review it. I find:
So we refactor. I explain why. They learn. We ship.
But here's the thing: they didn't write the original code. The AI did. So what did they learn? How to review AI code? Is that a skill? Should it be?
There's a paradox here. Junior developers need to write code to learn. But if AI writes the code, they're not learning to write code. They're learning to prompt AI and review its output.
Is that the same thing? I don't think so.
Writing code teaches you:
Reviewing AI code teaches you:
These are different skills. Both are valuable. But they're not the same.
There's a question I keep coming back to: is coding a craft anymore?
Traditionally, being a developer meant:
But if AI writes most of the code, what's left? Architecture? Code review? Prompt engineering?
I'm not saying these aren't valuable skills. But they're different from the craft of coding. And I'm not sure we know how to teach them yet.
Based on what I'm seeing, here's what junior developers actually need to learn in 2026:
1. Code Review Skills Not just "does this compile," but "is this the right solution?" "Does this fit our architecture?" "Will this be maintainable?" These are harder questions than they used to be, because the code looks correct even when it's wrong.
2. Prompt Engineering This sounds silly, but it's real. Knowing how to ask AI for what you need is a skill. Knowing when to refine prompts vs. when to write code yourself is a skill. This is new territory.
3. Architecture Understanding Juniors used to learn architecture by writing code and seeing what breaks. Now they need to understand architecture before they write (or generate) code. This is a higher bar.
4. Critical Thinking The biggest skill gap I'm seeing: juniors trust AI output too much. They need to learn to question everything. "Does this actually solve the problem?" "Is this the best solution?" "What are the edge cases?"
5. Debugging AI Code AI-generated code fails in different ways than human-written code. It's often "almost right" in ways that are hard to spot. Learning to debug AI code is a new skill.
Mentoring in this new world is harder. Here's why:
The Feedback Loop Is Broken Traditionally, I'd see a junior write code, spot issues, and explain. Now I see AI-generated code that a junior reviewed. The mistakes are different. The learning path is different.
The Skill Progression Is Unclear What does "getting better" look like? Is it writing better prompts? Reviewing code faster? Understanding architecture deeper? We don't have a clear progression anymore.
The Knowledge Gap Is Different Juniors know things I didn't at their level (they can generate working code faster). But they don't know things I did (how to think through problems from first principles). This creates a weird knowledge gap.
If juniors aren't writing code, what are seniors doing?
More Architecture I'm spending more time on architecture decisions. AI can write code, but it can't make architectural decisions. That's still human work.
More Code Review I'm reviewing more code, because there's more code being generated. But the review is different—I'm looking for different things.
More Integration AI writes code in isolation. Someone needs to integrate it. That's often me.
More Problem-Solving When AI code doesn't work, someone needs to figure out why. That's still me.
More Teaching I'm teaching different things now. Less "how to write a loop," more "how to think about problems."
Here's something interesting: studies show that experienced developers working on complex systems are actually slower when using AI tools. They perceive themselves as 20% faster, but they're actually 19% slower.1
Why? Because AI is great at routine tasks, but complex systems require deep thinking. AI can't do that. And the time spent reviewing and fixing AI code eats into the time saved generating it.
For juniors, the story is different. AI helps them write code they couldn't write otherwise. But that code often needs significant review and refactoring.
So we have a paradox: AI makes juniors more productive at writing code, but seniors less productive at reviewing it. The net effect might be negative.
Will AI eliminate junior developers? I don't think so. But I do think the role is changing.
What Won't Change:
What Will Change:
The role isn't dying. It's evolving. But evolution is messy, and we're in the messy part right now.
Here's how I'm adapting my mentorship approach:
1. Focus on Architecture First Before juniors write (or generate) code, we talk about architecture. What problem are we solving? What's the right approach? What are the trade-offs?
2. Code Review as Teaching When reviewing AI-generated code, I explain not just "this is wrong," but "here's why, and here's how to think about it next time."
3. Encourage Writing from Scratch I still have juniors write code from scratch sometimes. Not because it's efficient, but because it's how you learn. AI is a tool, not a replacement.
4. Teach Prompt Engineering I teach juniors how to use AI effectively. How to write good prompts. How to iterate. When to give up and write code yourself.
5. Emphasize Critical Thinking The most important skill: question everything. Don't trust AI output. Don't trust your own code. Think critically about every solution.
I don't think coding is dying. But I do think it's changing.
The craft used to be about writing code. Now it's about:
These are still valuable skills. They're still a craft. But it's a different craft than it was five years ago.
AI isn't eliminating junior developers. But it is changing what being a junior developer means.
The skills that matter now:
These are harder skills to teach. They're also more valuable.
As a senior developer, my job isn't to write code faster. It's to help juniors learn these new skills. To teach them to think critically. To help them understand architecture. To guide them as they learn to work with AI as a tool, not a crutch.
The craft isn't dying. It's evolving. And evolution is always messy. But we'll figure it out. We always do.
How is AI changing your role as a developer? Are you mentoring differently? I'd love to hear your thoughts. Find me on Twitter or Mastodon.
