Mentoring and Coaching Questions

Direct answer

Treat it as an active transfer project with an owner and a deadline, not passive documentation. Inventory what this person uniquely holds, rank it by risk rather than by how interesting it is to write up, transfer the highest-risk pieces through hands-on shadowing rather than just writing, and verify the transfer actually worked by having the successor perform the task for real while there's still time to catch gaps.

Transfer approach

Inventory and rank by risk, not by volume. List what this person actually holds that nobody else can currently do, then rank by what breaks or stalls if it disappears, not by what's easiest or most interesting to document. A fixed departure date means you can't transfer everything equally; risk ranking tells you where to spend the limited time.

Match the transfer method to the kind of knowledge. Procedural and tacit knowledge, how to actually make a judgment call under pressure, how to run something that doesn't go by the book, transfers best through shadowing and pairing, not documents. Declarative knowledge, why a past decision was made, historical context, transfers fine through writing, since there's no live judgment being exercised.

Verify the transfer actually happened, don't assume it. Have the successor perform the highest-risk task for real, a supervised dry run or an actual live instance, while the departing person is still around to catch what's missing. "They read the doc" is not verification.

Build in redundancy, not just a single successor. Naming one person as the new holder of the knowledge just recreates the same single point of failure with a different name on it.

Sequence by time pressure. The runway is fixed and shrinking, so the highest-risk items go first, even if lower-risk items would be quicker or more satisfying to knock out.

Worked example

Someone with deep knowledge of a specific system announces they're leaving in a few months. You inventory what they uniquely hold and rank it by risk: the thing that would cause the most damage if nobody understood it isn't the thing that's easiest to write a doc about, it's a judgment-heavy process that only they've ever run. You assign a primary and a backup successor rather than just one person. For that highest-risk item, instead of relying on a runbook, you have the successor run it for real under supervision before the departure date. During that supervised run, a real gap surfaces, a step the departing person did automatically and never thought to write down, and it gets caught and fixed while there's still time, instead of surfacing for the first time after they're gone.

Trade-offs and pitfalls

A knowledge-dump documentation sprint feels productive but is rarely sufficient on its own. What the departing person chooses to write down reflects what they consciously think matters, filtered through their own blind spots; the things that are automatic to them are exactly the things they won't think to write down.

Waiting until the final weeks to start is a common and costly mistake. Tacit knowledge transfer through shadowing takes real elapsed time to work, so it needs to front-load into the runway, not compress into the last stretch.

Verifying through a real supervised run costs more time, and carries some real risk, compared to just trusting a document. That cost is worth it, because it's the only way to catch a gap before it becomes expensive, rather than after.

Naming a single successor and calling the transfer complete just recreates the original risk with a new name attached. The goal isn't a new single point of failure; it's genuine redundancy.

Direct answer

Teaching a skill you don't have natural talent for means separating what you know intuitively from what's actually teachable. You diagnose the real gap first, build an explicit, decomposed framework for the skill (even though you perform it by feel), and validate progress by watching the person apply it independently, not by how confident the coaching sessions felt.

Approach to teaching outside your natural strength

Diagnose before prescribing. "Struggles with X" is rarely one problem. Watch or review their actual attempt and separate the layers: is it a knowledge gap (they don't know the structure), a delivery gap (they know the structure but execution is shaky), or a confidence gap (they know it and can do it, but freeze under real stakes). Each needs a different intervention.

Decompose your own tacit skill into explicit steps. If you're good at something without having consciously learned it as a framework, you have to reverse-engineer your own process before you can teach it. Skipping this step and just saying "do what feels right" doesn't transfer anything.

Practice at graduated, increasing stakes. Start with low-stakes reps where mistakes are cheap and recoverable, then move toward the real, higher-stakes version. Jumping straight to the real thing conflates skill-building with performance evaluation in the person's head, which raises anxiety and slows learning.

Give feedback on the mechanism, not just the outcome. "That worked" or "that didn't work" is much less useful than pointing at which specific move in their approach caused the result.

Worked example

Situation: someone you're mentoring is excellent at the core technical work but has a real gap in a skill that doesn't come naturally to you either, say, communicating findings clearly to people outside the immediate team. Their material was always technically sound, but reviews ran long and the point often got lost.

Task: help them close that gap over a defined stretch, without pretending you have natural talent for it yourself.

Action: you watched a recording of one of their sessions together and separated content problems (no clear headline, too much detail up front) from delivery problems (pace, not anticipating pushback). You gave them a simple structure to practice against: state the conclusion first, then the supporting evidence, then the recommendation. You ran a couple of low-stakes rehearsals where you played a skeptical stakeholder, then let them run the real session solo.

Result: over a few sessions, their reviews needed fewer clarifying follow-up questions from the room, and the structure started showing up unprompted in written material too, not just live presentations. The real signal wasn't how the coaching sessions felt: it was watching them handle a session you weren't part of and hearing secondhand that it landed cleanly.

Trade-offs and pitfalls

A common junior-mentor mistake is trying to transfer your own tacit competence directly ("just do what I do") instead of decomposing it. That fails specifically because the skill you're teaching is one you never consciously learned as steps.

Another mistake: avoiding coaching on gaps you don't personally excel at, on the theory you're not qualified. You don't need to be naturally gifted at a skill to teach its structure. You need to be willing to build the explicit framework, which sometimes non-naturals do better than naturals, because they had to learn it deliberately themselves.

The real trade-off is time. Teaching a skill outside your own strength takes longer to prepare for, because you can't rely on instinct in the room. That prep time is where the actual coaching value gets built.

Direct answer
Code review becomes a coaching tool the moment you separate what has to change before this merges from what's worth teaching, and handle each differently, since blocking mixes poorly with explaining. What counts as the important risk to teach toward also shifts by what's being reviewed: correctness and style for typical application code, reproducibility and data leakage for ML work, and blast radius for infrastructure changes.

Separate blocking feedback from teaching feedback

• Mark comments explicitly as blocking versus non-blocking (or use a similar convention), so the author isn't left guessing what actually has to change before merge. Teaching comments that aren't required for merge belong in the non-blocking bucket, otherwise you either water down real teaching moments to keep the change unblocked, or block a mergeable change to make a point.
• Ask before you tell: a comment phrased as a question ("what happens if this list is empty?") invites the author to find the issue themselves, which teaches the underlying reasoning; a comment phrased as an instruction just transmits the fix.

What "the important risk" means shifts by artifact type

• Typical application code: the coaching focus is usually correctness, readability, and test coverage; the failure mode being taught against is a defect shipping or the next person not being able to follow the change.
• ML notebooks and experiment configs: the review risk is different in kind, not just degree. The critical things to check and teach toward are reproducibility (is the seed pinned, is the environment specified, can someone else get the same result) and data leakage (does the training data have any path back to the evaluation set, directly or through a shared preprocessing step). A notebook can be clean, readable code and still be dangerously wrong for reasons that have nothing to do with code style.
• Terraform and other infrastructure-as-code changes: the review risk is blast radius, not defects in the traditional sense. A small, correct-looking diff can still be catastrophic if it touches a shared resource or removes a safeguard. Coaching here means teaching someone to ask what does this affect beyond what's in the diff before asking is this line correct.

Making it a genuine teaching moment, not just a gate

• When there's something worth teaching, don't just fix it in the comment; explain the why, and where useful, point to a real example elsewhere in the codebase rather than a generic principle.
• For anything too deep to unpack asynchronously in a comment thread, offer a short pairing session instead of a long comment chain; some things teach faster live than in writing.
• Close the loop: after a pattern comes up more than once for the same person, raise it directly in a 1:1 rather than only ever surfacing it inside individual review threads, so it becomes a recognized growth area instead of a recurring surprise.

Worked example
Reviewing a teammate's change that added a new model training script, the code itself was clean and well-tested in the conventional sense. The actual coaching moment was elsewhere: the evaluation split was built after a preprocessing step that had already seen the full dataset, which meant the reported accuracy was optimistic in a way unit tests would never catch. Rather than just fixing the split order and moving on, the comment walked through why that ordering matters (what leakage actually does to the reported number) and pointed to another script in the repo where the split happened correctly, before the shared preprocessing step. That change did get blocked, since the leakage was a real correctness issue, but the teaching part was the explanation of why, not the fact that it was blocked.

Trade-offs and pitfalls

• Making every comment a teaching moment, including on merge-blocking issues, slows delivery and can read as review turning into a lecture; save the deeper explanations for the genuinely worthwhile ones and keep routine fixes routine.
• Applying the same review lens (say, defect-finding) to every artifact type misses the risks that matter most for that artifact; a Terraform change reviewed like application code will pass style and correctness checks while missing blast radius entirely.
• If teaching moments only ever show up as isolated review comments and never get named directly to the person as a pattern, growth stays implicit and slower than it needs to be.

Direct answer
Adapting mentoring to someone different from yourself means adjusting the mechanism (how directive vs. how hands-off you are, how direct the feedback is, how much structure you provide) while keeping the underlying goal the same, and it requires actively noticing when your default style is a poor fit rather than assuming your own preferences are universal.

Structured elaboration

Adapting by competence and confidence: situational leadership

A useful framework here is thinking in terms of directing, coaching, supporting, and delegating, mapped to how much competence and confidence the person currently has for the specific task at hand (not their seniority in general, since someone senior can still be low-confidence on something genuinely new to them):

• Directing: low competence, needs clear instruction on what to do.
• Coaching: some competence but still needs explanation and encouragement, not just instruction.
• Supporting: solid competence, mainly needs encouragement and a sounding board, not instruction.
• Delegating: high competence and confidence, needs autonomy more than involvement.

The same person can sit in different quadrants for different tasks at the same time, so this is applied per-skill, not as a single label for the whole relationship.

Adapting to feedback-culture differences

How directly to give feedback isn't purely a personal style preference; it's shaped by cultural norms the mentee brings, and treating it as pure style risks an equity failure, not just a communication mismatch. Someone from a background where direct, blunt feedback is the norm may find indirect feedback confusing or even read it as a lack of respect for their ability to handle it; someone from a background where direct public correction is genuinely unacceptable may experience the same blunt feedback as disrespectful or even shaming, regardless of intent. Noticing which context someone is bringing, and adjusting delivery accordingly while keeping the substance intact, is part of doing this well rather than an optional nicety.

Adapting by seniority of the mentee

A junior mentee usually needs more structure, more explicit scaffolding, and more frequent checkpoints. A senior mentee needs something different: less procedural guidance, more of a thinking partner, and often an explicit expectation that they take on some mentoring of others themselves, since developing that skill is frequently the actual next step in their own growth, not something to route around.

Worked example

Situation

I mentored someone who worked best from a fully worked-out plan before starting anything ambiguous, while my own instinct is to start acting and figure out the plan as I go. Early on, my default approach (throw them a loosely scoped problem and let them work it out) was clearly causing more anxiety than growth; they'd stall rather than experiment.

Action

Instead of pushing them toward my own style, I adjusted the mechanism while keeping the goal (building comfort with ambiguity) the same: gave them explicit structure up front for the first few tasks (a rough plan to react to and revise, rather than a blank page), and deliberately widened the ambiguity only gradually as their confidence grew, checking in on how it felt rather than assuming.

Result

Over time they needed less upfront structure and became noticeably more willing to start from a loosely scoped problem on their own, which was the real signal of the adaptation working: not that they'd adopted my style, but that they'd built their own comfort with ambiguity at a pace that actually worked for them.

Trade-offs & pitfalls

• Assuming your own learning style is the default. The single most common failure here is mentoring the way you'd want to be mentored, rather than the way the specific person in front of you actually learns.
• Treating feedback-culture adaptation as optional politeness rather than an equity issue. Delivering feedback the same blunt way to everyone regardless of their background isn't neutral, it systematically disadvantages people for whom that style reads as disrespect rather than directness.
• Over-adapting to the point of never stretching the person. Adapting to someone's current style is different from leaving them there permanently; part of growth is gradually building comfort outside their comfort zone, not just permanently accommodating it.
• Forgetting that senior mentees need a different kind of adaptation, not just less attention. Assuming a senior mentee needs nothing from you, rather than a different kind of engagement (including expecting them to mentor others), under-invests in someone who still has real room to grow.

Direct answer
A stretch assignment only works as a growth tool if it's picked deliberately (real stakes, but survivable if it goes wrong), supported actively rather than handed off and hoped for, and evaluated by whether the person can now do something they genuinely couldn't before, not just whether the project shipped.

Picking the assignment

• Look for the specific gap between where someone is and where they want to go, and pick something that exercises exactly that gap: not a bigger version of what they already do well, but the thing they haven't had to do yet (leading ambiguity, owning a stakeholder relationship, making a judgment call without a clear right answer).
• Sanity-check the blast radius: a good stretch assignment has real consequences if it goes wrong, but not consequences the team or the person can't absorb. If failure would be catastrophic, it's not a stretch assignment, it's a bet you shouldn't be making on someone's first attempt.

Supporting through it

• Set explicit checkpoints rather than open-ended availability; someone stretching is often reluctant to ask for help exactly when they need it most, because asking feels like it undercuts the point of the assignment.
• Watch actively for the failure mode where the person becomes overwhelmed or delivery risk climbs mid-assignment. The fix isn't to quietly take it back (that undoes the growth and teaches them stretch assignments are a trap), it's to scope down the ask while keeping ownership intact: shrink the surface area, extend the timeline, or bring in narrow support on the hardest sub-piece, while the person still owns the outcome.

Knowing it worked

• The real signal isn't whether the deliverable shipped; plenty of stretch assignments succeed despite the person, propped up by others. The signal is whether they can now do a similar thing again with meaningfully less support than before.
• Ask them directly what they'd do differently next time; someone who's actually grown from it usually has a specific, concrete answer, not a vague "it was good experience."

Variants worth having ready

• Succession-driven: when someone owning a critical piece of the system is leaving, a stretch assignment can double as a deliberate handoff, usually spread across two or three people rather than one, so the knowledge doesn't just move from one single point of failure to another.
• Developing a mentor, not just a mentee: a technically strong senior who's never mentored can be given a stretch assignment that's explicitly about teaching, not delivery, such as owning a junior's ramp-up plan with the growth of the junior, not the speed of the project, as the success measure.

Worked example
A strong individual contributor wanted to grow into leading larger, more ambiguous work but had only ever executed against fully-scoped tasks. Rather than a bigger version of the same kind of work, the assignment was to own a smaller, genuinely under-scoped project end to end: figure out the actual requirements from a vague ask, make the technical calls, and report progress upward directly instead of through a lead. Support looked like a standing short weekly check-in (not daily oversight) and an explicit agreement that they'd flag it early if they felt stuck, rather than waiting until a deadline made the risk visible.

Partway through, the scope turned out to be bigger than either of us expected, and the person started showing the classic overwhelmed signs: shrinking updates, slipping the weekly check-in. Rather than pulling the project back, the assignment was rescoped down to the highest-value piece, with the harder edge case handed to someone else, while they kept ownership of the core decision and the delivery. They finished a smaller version of the original ask, and more importantly, on the next ambiguous piece of work a few months later, they scoped it themselves without needing the same weekly check-in structure. That second instance, done with much less support, was the actual evidence the stretch assignment had worked, not the fact that the first project shipped.

Trade-offs and pitfalls

• Picking a stretch assignment that's really just "more of the same, but bigger" doesn't build a new skill; it just tests stamina.
• Quietly rescuing someone the moment they look overwhelmed (taking the assignment back rather than rescoping it) protects the deliverable but teaches the person that stretching is unsafe, which discourages them from taking the next one.
• Measuring success by whether the deliverable shipped, rather than by what the person can now do independently, rewards you propping the project up rather than the person actually growing.