The Four Phases of Mentoring Juniors With AI

Part 3 of 3 — a series on mentoring juniors in the AI era

In Part 1, I argued that AI didn't kill juniors. It killed their runway — the protected window where they were allowed to be slow and figure things out.

In Part 2, I went through what AI doesn't teach: reading code you didn't write, debugging someone else's reasoning, sensing when "it works" means "it's done" versus "I got lucky."

This part is the practical one. If the runway is gone, and AI can't replace what it gave juniors, what do we actually do?

This is the model I now use with juniors on my team. Four phases. Sequential. No skipping.

Phase 1 — AI off

First few weeks. No Copilot. No Claude. No AI in the IDE.

This isn't hazing. It's not nostalgia for how things used to be. It's about building one specific thing: intuition.

When AI is on from day one, the junior never builds a baseline. They don't know what "normal" feels like in the codebase. They don't know which patterns are house style and which are accidents. They don't know what a hard problem looks like, because every problem gets the same fast answer.

Without that baseline, every later phase fails — because there's nothing to evaluate AI's output against.

A few weeks is enough. The goal isn't proficiency. The goal is having something to compare to.

Phase 2 — AI as a rubber duck

Now AI comes back — but only for explanation, not generation.

The allowed prompts look like this:

"Explain why this works."
"What does this pattern do here?"
"Walk me through this function."

The forbidden ones look like this:

"Write me a function that..."
"Implement..."
"Generate..."

This phase trains a specific muscle: using AI to understand, not to skip. The junior is still writing the code themselves. AI becomes the tireless senior they can ask anything, anytime, without feeling stupid.

This is also when they learn that AI confidently explains things wrong. Catching that early — while they're still writing the code by hand — is much cheaper than catching it later, when AI is also producing it.

Phase 3 — AI as a collaborator

Now generation is allowed. But with one rule: every output must be critiqued before it ships.

Not "does it pass tests." Not "does it look right." The junior must be able to say:

"This works, but it's wrong because X."
"This is correct but doesn't fit our pattern because Y."
"This solves the wrong problem — what we actually need is Z."

If they can't articulate something specific about the output, they don't ship it. They go back to the prompt, or they ask.

This is where most teams get stuck — they jump from Phase 1 straight to here. Without the rubber duck phase, the junior has no language for critiquing AI output. They just accept it or reject it on vibes.

Phase 4 — AI as a productivity tool

Only now does full-speed usage make sense. Boilerplate, refactors, scaffolding, mechanical edits — let AI handle it.

By this point the junior has:

A baseline for what the codebase feels like (Phase 1)
A habit of using AI to understand, not just produce (Phase 2)
A language for critiquing output (Phase 3)

Now they can move fast without losing the thread. They notice when AI is hallucinating. They catch the wrong pattern before it spreads. They use AI like a senior does — as leverage, not as a crutch.

This is the phase everyone wants to start in. It only works if the previous three phases gave them something to judge it against.

How long does each phase take?

I get this question a lot. Honest answer: it depends on the junior, the codebase, and what they're shipping.

But as a rough shape:

Phase 1: 2–4 weeks
Phase 2: 4–6 weeks
Phase 3: 2–3 months
Phase 4: ongoing

The exact numbers matter less than the order. Skipping is the failure mode, not pacing.

What this costs

This framework is slower than "give them Copilot on day one." Visibly slower in the first quarter. Probably slower in the second.

But the bet is that by month nine, you have an engineer who can actually use AI well — not someone who looks productive on paper but can't tell when their own code is wrong.

That bet is on you to make as a tech lead. No one above you is going to tell you to slow your junior down.

This series started with a problem: juniors entered a different game than we did, with no protected runway to learn on.

It ends with a choice. The runway is gone. We can either pretend it isn't and ship juniors who can't think without AI — or we can build a new runway. One that's shorter, more deliberate, and works with AI instead of around it.

That's not a failure of juniors. It would be a failure of mentoring if we don't.