Mentoring Junior Developers Effectively

// ❌ The dependency-creating pattern
interface BadMentoringSession {
  junior: "I'm stuck on this API endpoint";
  senior: "Oh, just do it like this: [writes the solution]";
  junior: "Thanks!"; // Learns nothing about how to arrive at the solution
  // Next week: same pattern, different endpoint
}
 
// ✅ The independence-building pattern
interface GoodMentoringSession {
  junior: "I'm stuck on this API endpoint";
  senior: "What have you tried so far?";
  junior: "I tried X but got error Y";
  senior: "Good instinct. What does that error message tell you?";
  junior: "That the response type doesn't match...";
  senior: "Right. And where is the response type defined?";
  junior: "In the schema file... oh, I see the mismatch.";
  // Junior learns: read error messages → trace to source → fix
}

interface MentoringOneOnOne {
  // Part 1: Check-in (5 min)
  checkIn: {
    energyLevel: 'high' | 'medium' | 'low';
    blockers: string[];
    wins: string[];  // What went well since last time
  };
 
  // Part 2: Growth review (15 min)
  growthReview: {
    currentChallenge: string;         // What they're working through
    skillsBeingDeveloped: string[];   // Explicit about what they're learning
    progressOnGoals: GoalProgress[];  // Track over weeks
  };
 
  // Part 3: Teaching moment (10 min)
  teachingMoment: {
    topic: string;         // One focused concept per session
    format: 'code-review' | 'whiteboard' | 'pair-programming' | 'discussion';
    takeaway: string;      // One sentence the junior should remember
  };
 
  // Part 4: Action items (5 min)
  actionItems: {
    forMentee: string[];   // Specific, achievable before next 1:1
    forMentor: string[];   // Resources to share, introductions to make
    nextMeeting: Date;
  };
}
 
interface GoalProgress {
  goal: string;
  status: 'not-started' | 'in-progress' | 'completed';
  evidence: string;        // Concrete examples of progress
  nextMilestone: string;
}

// ❌ Vague goals that can't be measured
const vagueGoals = [
  "Get better at TypeScript",
  "Learn more about architecture",
  "Improve code quality",
];
 
// ✅ Specific goals with observable outcomes
const specificGoals = [
  "Write a PR that uses generics correctly without my review guidance",
  "Draw a sequence diagram for the payment flow and explain tradeoffs",
  "Reduce the average number of review comments on PRs from 8 to 3",
];

type ChallengeLevel = 'too-easy' | 'growth-zone' | 'panic-zone';
 
function assessChallengeLevel(
  task: Task,
  menteeSkills: SkillProfile
): ChallengeLevel {
  const skillGap = task.requiredSkills.filter(
    skill => !menteeSkills.has(skill) || menteeSkills.proficiency(skill) < 0.5
  );
 
  if (skillGap.length === 0) return 'too-easy';
  if (skillGap.length <= 2) return 'growth-zone';  // Sweet spot
  return 'panic-zone';
}
 
// Scaffolding strategy based on challenge level
function determineSupport(level: ChallengeLevel): MentoringStrategy {
  switch (level) {
    case 'too-easy':
      return {
        style: 'delegate',
        checkInFrequency: 'weekly',
        guidance: 'Review the completed work, add stretch constraints',
      };
    case 'growth-zone':
      return {
        style: 'coach',
        checkInFrequency: 'daily',
        guidance: 'Pair on the hard parts, let them drive on the rest',
      };
    case 'panic-zone':
      return {
        style: 'direct',
        checkInFrequency: 'multiple-times-daily',
        guidance: 'Break into smaller pieces, pair closely, consider reassigning',
      };
  }
}

// ❌ Feedback that doesn't help
const unhelpfulFeedback = [
  "This code isn't great",                    // Vague — what specifically?
  "You should know this by now",              // Demoralizing, not actionable
  "This is wrong",                            // No direction provided
  "Just look at how I did it in the other PR", // Passive, unhelpful
];
 
// ✅ Feedback that drives learning
const effectiveFeedback = [
  // Specific: points to the exact issue
  "This function is doing three things — fetching, transforming, and saving. " +
  "Each of those should be a separate function so they can be tested individually.",
 
  // Timely: given during code review, not weeks later
  "I noticed this in your PR today — the error handling here swallows the " +
  "original error message. Let me show you a pattern for wrapping errors.",
 
  // Growth-oriented: explains the 'why'
  "This query works, but it'll slow down as the table grows because it's doing " +
  "a full table scan. Adding an index on `user_id` would fix it. Want to look " +
  "at the query plan together?",
 
  // Balanced: acknowledges what's good
  "The test coverage here is solid — you caught the edge case with empty arrays. " +
  "One thing to improve: the test names could be more descriptive about the " +
  "expected behavior.",
];

// ❌ Code review that teaches nothing
const unhelpfulReview = {
  comment: "nit: use const instead of let",
  // Junior changes let to const. Learns nothing about immutability.
};
 
// ✅ Code review that teaches a concept
const teachingReview = {
  comment: `Good catch using \`let\` here since you reassign it on line 15.
  
But consider: if you restructure to use \`.map()\` instead of the for-loop, 
you won't need reassignment at all:
 
\`\`\`typescript
// Instead of:
let results = [];
for (const item of items) {
  results.push(transform(item));
}
 
// You can write:
const results = items.map(transform);
\`\`\`
 
This is more idiomatic TypeScript and makes the code easier to reason about 
because \`results\` can never be accidentally reassigned later.`,
  // Junior learns: functional patterns, immutability benefits, idiomatic style
};

interface GrowthRoadmap {
  currentLevel: 'junior' | 'mid' | 'senior';
  targetLevel: 'mid' | 'senior' | 'staff';
  timeframe: string;  // "6 months", "1 year"
 
  tracks: GrowthTrack[];
}
 
interface GrowthTrack {
  name: string;
  skills: Skill[];
  projects: LearningProject[];
}
 
// Example roadmap for a junior → mid promotion
const juniorToMidRoadmap: GrowthRoadmap = {
  currentLevel: 'junior',
  targetLevel: 'mid',
  timeframe: '9 months',
  tracks: [
    {
      name: 'Technical Depth',
      skills: [
        { name: 'TypeScript generics', proficiency: 'intermediate' },
        { name: 'SQL query optimization', proficiency: 'intermediate' },
        { name: 'Testing strategies', proficiency: 'intermediate' },
      ],
      projects: [
        { title: 'Own and ship a feature end-to-end with no hand-holding' },
        { title: 'Debug and resolve a production incident' },
        { title: 'Refactor a module and measure the improvement' },
      ],
    },
    {
      name: 'Collaboration',
      skills: [
        { name: 'Give constructive code reviews', proficiency: 'basic' },
        { name: 'Write clear technical documentation', proficiency: 'basic' },
        { name: 'Break down ambiguous tasks', proficiency: 'intermediate' },
      ],
      projects: [
        { title: 'Review 20 PRs with substantive, teaching-oriented feedback' },
        { title: 'Write a design doc for a small project' },
        { title: 'Onboard the next new hire' },
      ],
    },
  ],
};