The way developers learn and work is rapidly evolving. AI-powered tools like GitHub Copilot, ChatGPT, and Cursor IDE have become embedded in daily workflows, offering junior developers an unprecedented level of on-demand support. Code can be written, explained, and optimized in seconds, often without leaving the IDE.

For mentors and senior developers, this creates a new kind of responsibility: guiding juniors who now lean heavily on AI tools. While these technologies can accelerate learning and productivity, they also risk creating a generation of developers who can write code but don’t understand it.

In this post, we explore in-depth strategies to help mentors balance trusting AI tools with ensuring deep learning and real developer growth.

1. Normalize AI Usage, But Set the Right Frame

Juniors may come into the workplace assuming AI is either a cheat code or a substitute for experience. As a mentor, your first job is to set the philosophical tone:

"Using AI isn’t cheating — it’s like working with a very fast, sometimes confused junior teammate."

Encourage juniors to view AI as a supportive assistant, not an oracle. Reinforce the idea that the developer is still responsible for understanding and owning the code.

Establish norms such as:

  • Use AI to draft, not finalize.
  • Never commit AI-generated code without reading and reasoning through it.
  • Ask AI "why" and "how" questions, not just "what" or "give me."

Implementation Tips

  • Include a short AI code review checklist during onboarding.
  • Create a Slack thread or Notion page where juniors can post AI-assisted insights and questions.

2. Focus on Why, Not Just What

One of the most dangerous habits AI can reinforce is accepting working code without understanding it. As a mentor, probe the mental model behind the code. AI may write syntactically correct solutions, but the semantic understanding must come from the developer.

When reviewing AI-assisted code:

  • Ask: "Can you walk me through this function step-by-step?"
  • Push for clarity: "What assumptions does this code make? Are they valid in our context?"
  • Dig deeper: "Why do you think Copilot suggested this? What pattern is it following?"

Make it clear that an explanation like "because ChatGPT said so" is not enough.

Implementation Tips

  • During code reviews, don’t just approve functionality — ask juniors to annotate the rationale behind decisions, especially for AI-suggested code.
  • Create sessions around AI dissection — take a generated snippet and collectively explore alternative implementations.

3. Encourage “Double-Checking” Skills

AI tools often produce plausible but incorrect solutions. Teaching juniors how to spot subtle bugs or inaccuracies is a crucial part of their growth.

Instill a healthy skepticism by asking:

  • "Have you tested this with invalid inputs?"
  • "What assumptions does this code make about the input or state?"
  • "What happens if this function is called concurrently or fails halfway?"

Encourage them to:

  • Cross-reference AI answers with documentation.
  • Use REPLs or playgrounds to verify behavior.
  • Write unit tests specifically targeting edge cases.

Implementation Tips

  • Run bug bounty challenges using only AI-generated code to see what issues emerge.
  • Assign reverse-engineering tasks: give juniors a working AI-generated function and ask them to derive the underlying logic.

4. Pair Programming Still Matters

AI may help juniors write code faster, but it does not replace the value of human mentorship in real-time problem-solving.

When you pair with a junior:

  • Watch how they interact with AI. Are they copying mindlessly or actively engaging?
  • Narrate your thought process aloud. Highlight decision-making, trade-offs, naming choices, and test strategy.
  • Ask them to "pause the AI" and attempt a solution solo, then compare it to what AI would do.

Pairing is your opportunity to model engineering thinking, not just coding.

Implementation Tips

  • Try 1:1 sessions where you each solve the same task — one with AI, one without — and then compare.
  • Use mob programming for larger features where juniors can observe seniors navigating ambiguity and complexity in real-time.

5. Model Responsible AI Use

As a mentor, you’re not just teaching code; you're teaching engineering culture. Be transparent about your own AI usage:

"Copilot suggested this, but I rewrote it for clarity." "I used ChatGPT to get started, then cross-checked with the docs."

Explain why you don’t always accept the AI’s answer. Let juniors see that even seniors don’t blindly trust AI, but use it critically.

Implementation Tips

  • Maintain a "debugging with AI" journal or shared log where team members reflect on when AI helped or hurt.
  • Include a retro topic: "What did AI get wrong this sprint?"

6. Teach the “Invisible” Skills AI Doesn’t Teach

AI can produce working code, but it doesn’t teach the skills that define a great developer:

  • Naming: Choosing clear, meaningful names that convey intent.
  • Testing: Writing expressive, maintainable test suites.
  • Trade-offs: Balancing readability, performance, and scalability.
  • Communication: Explaining code in reviews, tickets, and discussions.
  • Design Thinking: Modeling abstractions that evolve well.

Dedicate mentoring time to these topics explicitly. For example:

  • Review PRs together and focus only on naming and structure.
  • Pair on test writing without AI assistance.
  • Run short design review sessions for even small features.

Implementation Tips

  • Build a "non-code skills" checklist into your feedback process.
  • Create shared rubrics that include clarity, intent, and testing rigor.

7. Celebrate Curiosity, Not Just Output

AI can help juniors move fast, but depth is more important than speed. Reward moments where juniors:

  • Challenge an AI suggestion.
  • Rewrite AI code for readability.
  • Ask foundational questions (e.g., "What’s the time complexity of this?").
  • Investigate why AI failed in a specific case.

Help them understand that the best developers aren’t the fastest — they’re the most curious and thoughtful.

Implementation Tips

  • Shout out moments of good judgment or deep inquiry in retros.
  • Start a #curious-junior Slack channel where thoughtful questions are celebrated.

Conclusion

AI tools are a powerful addition to the developer toolbox, especially for juniors learning the ropes. But without intentional guidance, they risk becoming crutches rather than catalysts.

As a mentor, your role is more vital than ever. You must help juniors use AI tools critically, intentionally, and responsibly. That means going beyond code correctness and fostering a mindset of curiosity, skepticism, and thoughtful engineering.

So embrace AI. Use it. Teach it. But never stop asking: does this developer understand what they’re doing — and why?

That’s the real job of mentorship in the age of AI.