The Art of Technical Mentoring

Mentoring is one of the most valuable things you can do as a senior engineer—and one of the easiest to get wrong. Many people think mentoring means giving quick answers, fixing PRs, or "saving" projects. But good mentoring actually enables others to save themselves.

The goal of mentoring isn't to create "mini versions" of the mentor. It's to help mentees build thinking patterns, work habits, and confidence to make increasingly independent technical decisions.

What Mentoring Is

Effective mentoring usually rests on four pillars:

Guidance — sharing experience, context, and ways to weigh trade-offs
Support — being there when mentees need help, without taking over
Challenge — pushing growth through problems "just above" their current level
Advocacy — opening doors: recommending, giving spotlight, shielding from unnecessary politics

In short, mentoring is about long-term capability, not this week's output.

Mentoring vs Teaching vs Coaching

These three often get mixed up, but their focuses differ:

Teaching: "Here's the concept, here's an example." Best when mentees lack foundation.
Coaching: "What do you want to achieve? What's blocking you? What options do you have?" Ideal for building reflection and habits.
Mentoring: A blend of both, plus experience-based perspective and navigation of context (team, product, career).

A great mentor switches modes as needed, but always remembers: the end goal is mentee independence.

The Socratic Method

One of the most powerful techniques is the Socratic Method: asking questions to help mentees think, not handing them ready answers.

Instead of "Just do it this way, done," you guide mentees to list options and choose with clear reasoning.

text

Mentee: "How should I structure this component?"
Mentor: "What options do you see? What are the trade-offs?"

Some questions I use often:

"If we pick option A, what do we sacrifice?"
"What's the most critical constraint here: performance, readability, time-to-ship, or future changes?"
"If this feature changes in 3 months, which part is most likely to break?"
"What's the smallest safe step to test our assumption?"

Upgrade: Socratic + Guardrails

Pure Socratic can feel like an interrogation without direction. To keep it warm and effective, add guardrails:

Provide context: "There are a few common patterns—let's pick the best fit."
Set time limits: "We'll explore for 10 minutes, then commit to one option."
Give minimal examples: "If stuck, start with the simplest option."

A Practical Mentoring Playbook

Here's the most "daily-use" approach in practice.

1) Set Clear Expectations

At the start, agree on basics:

What to achieve (e.g., more confidence in React patterns, system design, testing, or technical communication)
Rhythm (e.g., 30 minutes/week)
Workflow (async via PR comments + sync sessions for big stuff)

The point is simple: make mentoring a consistent process, not "if there's time."

2) Teach Decision-Making, Not Decisions

When mentees ask "X or Y?", train them to make accountable choices:

List 2–3 options
Outline trade-offs
Pick one with reasoning (and what to monitor post-choice)

Mentees who level up aren't those who memorize libraries—they're the ones who make decisions with a clear framework.

3) Give Specific, Actionable Feedback

Use a simple format:

Observation: "In this PR, I see you changed 5 things at once."
Impact: "Reviews take longer and bugs are harder to track."
Suggestion: "Try splitting into 2 PRs: refactor first, then behavior changes."

Avoid vague feedback ("less tidy," "make it cleaner")—it gives no path forward.

4) Ramp Up Challenges Gradually

Steadiest growth happens when challenges are just above current skill. For example:

Weeks 1–2: Execute scoped tasks
Weeks 3–4: Design solutions + write short RFCs
Week 5+: Lead small end-to-end implementations, including testing and rollout plans

Too easy? They stagnate. Too hard? They lose confidence.

5) Turn PR Reviews into Scalable Mentoring Sessions

PR reviews are the most effective mentoring spot—real and contextual. Helpful patterns:

Ask intent: "What's the goal of this change?"
Request written reasoning: "Why this approach?"
Teach standards: "What's 'done' for this component?" (accessibility, loading states, empty states, testing)

Consistency here means mentees internalize standards without constant reminders.

Conclusion

Great mentoring feels like an investment: it may not yield "quick wins" this week, but the effects compound, making your team much stronger.

If you remember just one line, make it this:

The best mentors create more mentors—not more followers.