# Stop Giving AI Tools to Juniors — Pilot to Production

> Everyone thinks AI tools suit juniors. Wrong: seniors spot mistakes, juniors accept everything. Why your AI rollout should start with the skeptics.

Canonical: https://thegrowthproject.com/podcast/stop-giving-ai-tools-to-juniors/

*Pilot to Production*, the Growth Project podcast — hosted by Sam and Maya.

- Listen: https://thegrowthproject.com/podcast/stop-giving-ai-tools-to-juniors/
- Read the article: https://thegrowthproject.com/blog/stop-giving-ai-tools-to-juniors/
- Audio: https://thegrowthproject.com/audio/podcast/stop-giving-ai-tools-to-juniors.m4a?v=fe55d639

## Transcript

**Sam:** Everyone says the same thing. Our juniors are struggling, they're slower than the seniors, so give them the AI tools. That'll help them catch up.

**Maya:** It's backwards. The person who should touch AI first isn't your newest hire. It's the senior who rolls their eyes at every new tool.

**Sam:** Welcome to Pilot to Production, from the Growth Project. I'm Sam.

**Maya:** And I'm Maya. Today: why you should stop giving AI tools to juniors, and hand them to your most skeptical senior instead.

**Sam:** Okay, but defend that. The logic feels airtight. Less experience, more help needed, give them the help.

**Maya:** It's the same logic that makes new drivers seem like good candidates for autopilot. They need the most help, right?

**Sam:** Sure. Put the assistance where the weakness is.

**Maya:** Except new drivers don't know when the autopilot is about to drive into a truck. They trust the machine. Experienced drivers stay suspicious. They know when to grab the wheel.

**Sam:** And AI code generation is the autopilot in that story.

**Maya:** Exactly. The post puts it bluntly. A developer Daniel respects said, do not give AI tools to interns and juniors expecting good results. Take your skeptical senior, convince them to do vibe engineering, and you'll get ten x results.

**Sam:** Vibe engineering. Define that, because it sounds like the opposite of careful.

**Maya:** It's the opposite of blind. Using AI tools while staying suspicious. Watching what the AI produces, catching mistakes, redirecting when it goes wrong. Supervising, not accepting.

**Sam:** So why does that only work for seniors? What's the actual mechanism?

**Maya:** Because AI tools are amplifiers, not teachers. They amplify what you already know. If you know what good code looks like, you spot when the AI produces garbage. If you don't, you accept everything.

**Sam:** And the junior accepting everything actually looks great on paper.

**Maya:** They look productive. Shipping features in half the time. But those features have bugs. Edge cases. Security holes. Integration issues that don't surface until production.

**Sam:** While the senior looks slow.

**Maya:** Pushing back on suggestions. Rewriting whole sections. Adding context the AI missed. Then their code runs. In production. Without the three a m wake-up calls.

**Sam:** There's a spectrum in the post too. Three groups.

**Maya:** Right. Juniors say, give me everything. Mid-level developers say, this will never be good enough, my code is better. And the super seniors say, this is a tool, let me use it properly.

**Sam:** Funny that it's the mid-levels who resist hardest.

**Maya:** They resist defensively. The super seniors, the ones who've written frameworks and shipped systems at scale, they get it. Because they know one thing the others don't. Judging what's good enough is a skill.

**Sam:** Unpack that, because perfectionism sounds like a senior trait.

**Maya:** Not everything needs to be perfect. Some code just needs to work, be readable, be maintainable. The super seniors know the difference between this is fine and this will break at two a m on a Friday. AI can't teach you that. You learn it by being the one who fixes things at two a m.

**Sam:** So what do seniors actually do differently at the keyboard?

**Maya:** Five things. They know when to stop, because AI will keep generating forever. They spot the wrong direction early. AI code generation starts wrong, regularly. A junior builds on the mistake. A senior stops after three lines and says, no, that's not how we handle this.

**Sam:** That's three. Keep going.

**Maya:** They provide context the AI can't infer. Why does this function exist, what constraint led to this design. They treat AI as a collaborator, not an oracle. They watch it like a suspicious colleague. What are you doing, why, show me.

**Sam:** And the fifth.

**Maya:** They know the codebase. The patterns, the anti-patterns, the things that have been tried and failed. AI doesn't know any of that. Seniors do.

**Sam:** Is there anything backing the ten x claim, or is it vibes?

**Maya:** GitHub's research backs it up. Experienced developers see the biggest productivity gains from AI tools. Not because they type faster. Because they know what to accept and what to reject. And it compounds. Clean code lets AI be more effective next session. Messy code makes everything harder.

**Sam:** Okay. First thing tomorrow morning. Someone's listening, they run a team. What do they do?

**Maya:** Identify your skeptical senior. The one who asks why too much. Make the case that this is amplification, not replacement. Then start them on one contained project with clear scope, no pressure, and watch what they do differently.

**Sam:** And how do they know it worked?

**Maya:** Measure what matters. Not lines of code, not features shipped. Bugs in production. Time to resolution. Code that survives unchanged. Those reveal quality. Then scale from there.

**Sam:** So the one-line version.

**Maya:** Give AI to people who don't know what good looks like, you get mediocrity at speed. Give it to people who do, and you get something genuinely useful. Your most skeptical senior isn't the last person who should adopt AI. They're the first.

**Sam:** This has been Pilot to Production, from the Growth Project. If your AI rollout is aimed at the people who can't see the mistakes, that's the gap we close, at thegrowthproject.com.

**Maya:** Thanks for listening. See you next time.