Mentoring Go Developers Across Experience Levels

Teaching concurrency, errors, and testing effectively.

Mentoring on Go teams is how idioms outlive any single senior hire.

Structured plans beat ad-hoc advice: juniors need safe baselines, mids need concurrency fluency, seniors need design ownership, and staff candidates need multi-team teaching leverage.

Summary

Effective mentoring matches exercises to leveling expectations.

Juniors practice gofmt, table tests, and explicit error returns.

Mid-level engineers pair on context, channels, and interface boundaries.

Seniors co-own design reviews and ADR drafts.

Staff-track engineers demonstrate cross-package patterns through reference PRs and review calibration.

Every level benefits from artifacts - merged PRs, test files, doc notes - not verbal promises to improve.

Recipe

Quick-reference recipe card - copy-paste ready.

## Mentoring plan - <name> - <level>
 
Quarter goal:
Week 1-4: <skill> -> artifact PR
Week 5-8: <skill> -> artifact PR
Review themes to watch: errors, concurrency, API exports
Buddy rotation: <engineer> by week 6

When to reach for this:

• New hire ramp after onboarding checklist
• Promotion calibration quarter
• Repeated review themes on one engineer
• Preparing a senior for tech lead or staff scope
• Recovering confidence after a production incident involving their code

Working Example

Mentor guides a mid-level engineer through concurrency in a real queue consumer.

func TestWorkerRespectsCancel(t *testing.T) {
    ctx, cancel := context.WithCancel(context.Background())
    defer cancel()
 
    w := NewWorker(fakeSender{delay: 50 * time.Millisecond})
    done := make(chan error, 1)
    go func() { done <- w.Run(ctx) }()
 
    time.Sleep(10 * time.Millisecond)
    cancel()
 
    select {
    case err := <-done:
        if !errors.Is(err, context.Canceled) {
            t.Fatalf("got %v want cancel", err)
        }
    case <-time.After(time.Second):
        t.Fatal("worker did not stop")
    }
}

// Mentor asks author to add -race in CI job comment on PR
// go test -race ./internal/worker/...

What this demonstrates:

• Tests prove shutdown behavior, not only happy path
• context cancellation is verifiable in unit tests
• Mentor ties exercise to production incident class (stuck workers)
• Race detector becomes a habit before merge

Deep Dive

How It Works

• Mentor and mentee agree on one measurable quarterly outcome (for example, "own concurrency PRs without rework").
• Weekly 30-minute sessions follow an agenda: review last PR, teach one concept, assign micro-PR homework.
• Buddies rotate monthly so mentees hear multiple review voices.
• Progress evidence lives in tickets: links to PRs, test files, design comments.

Level-Specific Focus

Go Notes

// Error lab: mentee refactors to %w and adds errors.Is test
var ErrNotFound = errors.New("not found")
 
func TestIsNotFound(t *testing.T) {
    err := fmt.Errorf("load: %w", ErrNotFound)
    if !errors.Is(err, ErrNotFound) {
        t.Fatal("expected ErrNotFound in chain")
    }
}

• Teach wrapping at the layer that adds context, not every log site.
• Interfaces defined by consumers: exercise with io.Reader style examples from their codebase.
• Generics: show when type parameters clarify APIs vs unnecessary abstraction.

Teaching Concurrency Safely

• Start with sequential code correct under errors before introducing goroutines.
• Introduce errgroup before raw channel orchestration for most service code.
• Require go test -race on packages touched; explain a past race found in prod if available.
• Never assign on-call primary for untested concurrent paths.

Gotchas

• Lecture-only mentoring - Fix: Every session ends with a PR or ticket update due within one week.
• Same buddy forever - Fix: Rotate after 4-6 weeks to expose review diversity.
• Skipping juniors on design - Fix: Invite observers to design reviews early; assign comment homework.
• Teaching frameworks before stdlib - Fix: Anchor on net/http, context, and testing before chi/gin exceptions.
• Vague "be more senior" feedback - Fix: Map to leveling guide bullets with evidence checklist.
• Mentor unavailable during crunch - Fix: Protect calendar blocks; crunch without mentoring burns future velocity.

Alternatives

FAQs

Related

• Technical Leadership in Go Teams - growth loop in leadership model
• Tech Leadership Basics - mentoring block scheduling example
• Onboarding Go Specialists - ramp from other languages
• Code Review Culture for Go - teaching through PRs
• Leveling Guide: Junior to Staff in Go - expectations by band
• Pairing & Mob Sessions for Go Teams - live teaching formats

Stack versions: This page was written for Go 1.26.x (Green Tea GC default, go fix modernizers - verify patch at build), chi (latest - verify at build), gin (latest - verify at build), echo (latest - verify at build), google.golang.org/grpc (latest - verify at build), sigs.k8s.io/controller-runtime (latest - verify at build), kubebuilder (latest - verify at build), tinygo (latest - verify board targets at build), wazero (latest - verify at build), and golangci-lint (latest - verify linter set at build).