I’ve spent a lot of time thinking about how AI changes the mentorship relationship. Not just because AI tools are new and interesting, but because the fundamental dynamic of teaching someone to code shifts when they can just ask a machine for answers. As senior developers, our role isn’t obsolete—but it is evolving. Here’s how I think about mentoring now.
The Old Model Doesn’t Work the Same Way
Traditionally, mentorship often looked like this: a junior developer gets stuck, asks a senior for help, the senior either solves the problem or guides them toward a solution, and in the process, the junior learns. The senior’s value came from having already solved similar problems, from knowing the codebase, from understanding the patterns.
That model still has value, but it’s no longer the primary way juniors get un-stuck. Now they paste an error message into Claude or ChatGPT and get an answer in seconds. They can ask AI to explain unfamiliar code, to generate examples, to walk them through concepts. They basically have an always-available tutor that never gets tired of explaining things.
This changes what we mentor. We can’t just be the person who has answers, because AI has answers too, often faster and more patiently than us. Where we add value is in the stuff AI can’t provide: context about the business, judgment about what’s worth building, experience with what happens when systems fail, and the knowledge that only comes from years of making mistakes.
What Senior Developers Can Offer
Context that AI lacks. When a junior asks about whether to refactor a chunk of code, AI can explain the trade-offs in theory. But it doesn’t know that your team has a deadline next week, or that this particular module has been stable for years, or that the company is about to pivot away from this feature entirely. We have context that shapes what the right answer actually is.
Judgment about what matters. There’s a difference between code that works and code that’s worth writing. A junior can ask AI to generate a feature, but they can’t easily judge whether that feature is worth the complexity it adds, whether it aligns with product goals, or whether it’s worth maintaining long-term. This judgment comes from experience—we can help transfer it.
Debugging the hard problems. AI is great at generating code and explaining familiar patterns. It’s much worse at debugging issues that span multiple systems, involve subtle race conditions, or require understanding organizational context. When the problem is genuinely hard, human expertise matters more, not less.
Learning how to learn. This one is underrated. How do you break down a complex problem? How do you know what you don’t know? How do you evaluate whether you understand something? These meta-skills become more important when execution is easier—knowing what to build matters more when building is fast.
Practical Ways to Mentor Now
Given how things have changed, here’s how I approach mentorship differently:
Focus on questions, not answers. Instead of solving problems for juniors (or having AI do it), ask them questions that guide their thinking. What have you tried? What do you think is happening? What would you do if you had to guess? This builds the reasoning skills that AI can’t replicate.
Discuss the “why” more than the “how.” AI can teach the how—here’s syntax, here’s a pattern, here’s how to implement this. The why is where humans add value. Why does this architectural choice make sense? Why would we choose this approach over that one? Why does this problem matter to the business?
Model debugging and problem-solving. Show juniors how you approach a hard problem. Talk through your thinking. Explain how you know what to Google, how you narrow down issues, how you decide when to ask for help. This kind of thinking out loud is something juniors rarely get to see.
Help them use AI well. Instead of pretending AI doesn’t exist, help juniors use it effectively. Show them how to write good prompts, how to evaluate AI suggestions critically, how to learn from AI explanations rather than just copying answers. The developers who use AI thoughtfully will outperform those who ignore it or rely on it too heavily.
Create space for struggle. It’s tempting to let AI solve problems for juniors to save time. But that struggle—the frustration of not understanding, the satisfaction of finally getting it—that’s where growth happens. Let them struggle appropriately, then help them reflect on what they learned.
The Relationship Matters
One thing AI can’t replicate is the human relationship. Juniors don’t just need answers; they need someone who believes in them, who can provide perspective, who can advocate for them, who can help them navigate career decisions. Mentorship is about more than technical skills. It’s about having someone in your corner.
Make time for the human side. Ask about their goals. Share your own experiences, including failures. Be someone they can talk to about the non-technical parts of being a developer. That connection is the part that actually sticks with people long after they’ve forgotten the specific code you helped them with.
Our Responsibility
As senior developers, we have a responsibility to the next generation. They’re coming into an industry that’s genuinely uncertain about what AI means for their careers. They’re navigating tools that change weekly. They’re trying to learn in an environment where the easy answers are always available.
Our job is to help them build the skills that matter, to share the perspective we wish we’d had, and to support them as they figure things out. AI changes the specifics of how we mentor, but the core responsibility is the same one it’s always been: we were junior once too, and someone helped us. Now it’s our turn.
