Junior developers and AI: code review as mentorship

How AI coding tools are reshaping the path from junior to senior, and what engineering leaders are getting wrong

In February 2025, AI researcher Andrej Karpathy coined a term that captured what senior developers had been nervously observing: "vibe coding." Developers accepting AI suggestions without understanding them, shipping code they can't debug, building systems they can't maintain.

The numbers are astonishing. A Stanford Digital Economy Lab study found that employment of workers aged 22 to 25 in AI-exposed occupations, which include software developers, is 19% below where it would be had it kept pace with less-exposed peers. Companies view AI as a replacement for junior developers rather than as an amplification tool. In LeadDev's AI Impact Report 2026, a survey of 600 engineering leaders, 62% expect fewer junior engineers to be hired.

For the juniors who are hired, code review is where they can still learn to understand and debug the code they ship, as long as reviewers explain the reasoning behind each change.

TLDR

Junior developers produce more code with AI coding tools, but often don't understand what they're shipping. This creates the "Silent Silo" problem: juniors stop asking questions because AI answers them, but never develop the judgment needed for senior roles. 

Teams that use code review as an interactive learning tool, with explanations instead of bare fixes, help juniors build the judgment senior roles need. That matches the research on why teams do code review, where studies at Microsoft and Google found that review spreads knowledge of the code as well as catching bugs.

AI makes juniors faster, but not necessarily better

A 2025 METR study tracked 16 experienced developers as they completed 246 real-world coding tasks. Developers using AI tools were 19% slower than without assistance. They didn't realize it, but they estimated AI increased productivity by 20%. That's a 39-point gap between perception and reality. METR has since said these early-2025 results no longer reflect the current impact of AI models. Its February 2026 update says developers were likely sped up more by AI tools in early 2026 than in its early-2025 estimates, but that its new data is only very weak evidence of how much.

For juniors, the consequences hit harder. They produce far more code with AI tools for code, but this code requires extensive senior review. At the team level, DORA's 2025 research found that AI adoption now has a positive relationship with software delivery throughput but still a negative one with delivery stability.

In a January 2026 Anthropic study of 52 mostly junior software engineers learning a new Python library, the group that used AI averaged 50% on a follow-up quiz, against 67% for those who coded by hand, and the largest gap was on debugging questions. Juniors become fluent in accepting suggestions but illiterate in understanding what those suggestions actually do.

The Silent Silo problem: Juniors stop asking questions. Why interrupt a senior when ChatGPT can answer? But AI can't teach judgment, when to use a hash map versus an array, why immutability matters in concurrent systems, and how to balance performance against maintainability. These lessons come from code review conversations where seniors explain why they're suggesting changes.

The result? "Archaeological programming." A developer in 2030 debugs a system built in 2025. They're looking at code that works but makes no sense. The commit history shows "AI improvements" with no explanation. Every modification risks breaking something unpredictably because the original developers moved on, and the AI that created the code no longer exists.

Using code review as a mentorship platform

Code review platforms go beyond bug detection. They help teams learn with every pull request.

1. Learning from senior patterns automatically: When your seniors consistently explain why direct database access violates your architecture, patterns start to form. With automated code fixes by coding agents, those patterns can be applied consistently across pull requests. 

The next time a junior makes the same mistake, they see the reasoning seniors have shared before and the architectural thinking behind it, instead of a bare correction.

2. Interactive learning through chat: Static linters flag issues without context. AI code review integration platforms include chat functionality, letting juniors ask questions about suggested changes: "Why is this a race condition?" "What's the difference between these approaches?" "How would this perform at scale?"

Juniors learn while the context is fresh instead of waiting hours for senior review and scheduling calls to discuss feedback. In cubic, a junior can reply to a review comment to ask why, or ask the AI chat for a guided tour of a pull request that stops at each part of the change.

3. Understanding systems beyond the diff: A diff shows only the lines that changed. Understanding why code works requires understanding the entire system.

When cubic reviews a pull request, it reads the change with context from the whole repository, so the review can explain how a junior's change affects the rest of the system. Separately, codebase scans run thousands of AI agents across a repository, on a schedule or on demand, to find bugs and security vulnerabilities already in the code.

A review comment on a junior's change might look like this:

// Junior's code:
export async function deleteUser(id: string) {
  await db.users.delete(id);
  return { success: true };
}

// Example review comment:
⚠️ This deletion creates orphaned records. Your codebase has 4 tables
with foreign keys to users:
- subscriptions (src/billing/models.ts)
- sessions (src/auth/session.ts)
- notifications (src/notifications/queue.ts)
- audit_logs (src/logging/audit.ts)

Other deletion handlers use a transaction pattern to cascade deletes.
See deleteAccount() in src/auth/service.ts for an example

// Junior's code:
export async function deleteUser(id: string) {
  await db.users.delete(id);
  return { success: true };
}

// Example review comment:
⚠️ This deletion creates orphaned records. Your codebase has 4 tables
with foreign keys to users:
- subscriptions (src/billing/models.ts)
- sessions (src/auth/session.ts)
- notifications (src/notifications/queue.ts)
- audit_logs (src/logging/audit.ts)

Other deletion handlers use a transaction pattern to cascade deletes.
See deleteAccount() in src/auth/service.ts for an example

// Junior's code:
export async function deleteUser(id: string) {
  await db.users.delete(id);
  return { success: true };
}

// Example review comment:
⚠️ This deletion creates orphaned records. Your codebase has 4 tables
with foreign keys to users:
- subscriptions (src/billing/models.ts)
- sessions (src/auth/session.ts)
- notifications (src/notifications/queue.ts)
- audit_logs (src/logging/audit.ts)

Other deletion handlers use a transaction pattern to cascade deletes.
See deleteAccount() in src/auth/service.ts for an example

This teaches juniors to think in systems. Changes ripple through dependencies. Patterns exist for reasons. Code quality checks are guardrails based on hard-won lessons.

Enforcing standards while explaining them: Custom agents let teams codify conventions that AI-based code review enforces automatically. The key is making these educational:

When a junior violates this pattern, they get reasoning. They understand downstream impact: how frontend developers consume these errors, how monitoring systems rely on the structure, and why exposing stack traces is a security risk.

This is exactly why structured code review matters. A practical code review checklist, covering security, performance, and maintainability, helps teams turn these patterns into repeatable standards.

How to structure teams for AI-accelerated learning

• Pair AI review with human mentorship: AI handles repetitive feedback (formatting, common mistakes, standards violations). Our AI code review guide covers what an AI first pass catches and what it leaves for the human reviewer.

• Require understanding before merging: Before merging AI-suggested code, juniors should explain what it does in their own words. If they can't explain the code they're shipping, they haven't learned from it. For the reviewer's side, see how to review AI-generated code.

• Use the AI wiki for exploration: Juniors can ask cubic's AI wiki plain-English questions such as "Where do we handle rate limiting?" and get answers with code references, which turns the codebase into a learning resource.

• Make learning visible: Track which AI suggestions juniors accept versus modify. Developers who blindly accept everything aren't learning. Developers who question suggestions, modify them based on context, and gradually need fewer corrections are developing judgment.

What the research says

How juniors use AI also matters. In Anthropic's analysis of its study, participants who asked the AI follow-up questions, asked for explanations or asked only conceptual questions averaged 65% or more on the quiz. Those who relied on the AI to write or debug their code averaged under 40%. The groups were small, 2 to 7 people each, and Anthropic says its analysis does not draw a causal link between these patterns and learning outcomes.

Success is measured by how quickly junior developers gain confidence and autonomy.

The choice: Two paths for junior developers with AI

AI will reshape how junior developers learn to code. The outcome depends entirely on the implementation strategy.

The replacement path: Juniors use AI as a black box, accepting suggestions without understanding, shipping code they can't maintain, and building skills in prompt engineering rather than software engineering. This creates developers who can generate code but can't explain it, who become stuck when AI suggestions fail, and who never develop the deep understanding required for senior roles.

The amplification path: Teams use code review platforms as interactive learning tools. Juniors get immediate, contextual explanations for feedback. They explore patterns across the entire codebase. AI handles repetitive explanations, so seniors focus on teaching judgment and architecture.

The difference between these paths isn't the technology. Every team has access to AI coding tools. The difference is whether you use AI code review integration as an approval stamp or a mentorship platform. An approval stamp is what reviewers call a rubber-stamp LGTM, and our LGTM guide covers when LGTM is a warning sign.

Making the call: What junior developers need from you

Junior developer growth depends on structured mentorship, not AI alone. Poor mentorship creates the Silent Silo problem, where juniors ship code without understanding it.

Your juniors will use AI code assistants either way. The question is whether you'll give them tools that teach them to understand code or only help them ship it.

Ready to turn code review into a mentorship tool?

Book a demo to see how cubic reviews each pull request against your whole codebase and lets juniors ask follow-up questions in chat.