# How to Get Senior Engineers to Adopt AI Tools — Pilot to Production

> Your seniors are skeptical of AI tools. Good. That skepticism is exactly why they'll get 10x results. Here's the tactical playbook for adoption.

Canonical: https://thegrowthproject.com/podcast/senior-engineers-ai-tools/

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

- Listen: https://thegrowthproject.com/podcast/senior-engineers-ai-tools/
- Read the article: https://thegrowthproject.com/blog/senior-engineers-ai-tools/
- Audio: https://thegrowthproject.com/audio/podcast/senior-engineers-ai-tools.m4a?v=47032d7a

## Transcript

**Sam:** An AI tool ships plausible-looking garbage. A junior says "looks good." It breaks in production at two in the morning.

**Maya:** And now a senior is debugging code they didn't write, from an AI they didn't supervise, approved by someone who didn't know better.

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

**Maya:** And I'm Maya. Today: why your most skeptical senior engineer is the right person for AI, and your eager junior is the wrong one.

**Sam:** Okay, that's backwards. Juniors need more help. AI gives help. Give AI to juniors.

**Maya:** That's the instinct, and it's exactly why AI adoption fails on so many teams. Juniors don't know what good code looks like yet. They can't spot when the AI is wrong. They accept suggestions on autopilot.

**Sam:** So the tool produces garbage, the team loses trust in the tool.

**Maya:** Right. They gave the tool to the wrong people. The one skill that matters here is knowing when code is good enough.

**Sam:** Good enough. Not perfect, not clever.

**Maya:** Solves the problem. Doesn't break things. Maintainable by the next person. That comes from years of shipping, years of debugging, years of seeing what breaks and what lasts. AI tools don't teach that. They obscure it.

**Sam:** Then why do seniors push back so hard? If they're the right people, you'd think they'd jump.

**Maya:** A few reasons, and all of them are healthy. One, they've seen hype cycles before. Every few years something promises to change everything, and most of it doesn't.

**Sam:** So they wait for the tool to prove itself.

**Maya:** Two, they're protective of their craft. Writing code well took years to develop. An AI that writes "good enough" code feels like a threat. Three, they see the flaws. The edge cases missed, the patterns broken, the abstractions that cause problems later.

**Sam:** They're not impressed by the demo. They're evaluating production readiness.

**Maya:** Exactly. And four, "good enough" feels like an insult. Mid-level developers are the most resistant of all, because that's the stage where craft matters deeply.

**Sam:** So they read "good enough" as "lower your standards."

**Maya:** And the mistake managers make is treating that resistance as a problem to overcome. It isn't. It's the exact quality you want in someone supervising AI.

**Sam:** Okay, so how do you pitch it without setting off every alarm they have?

**Maya:** Not "AI will write your code for you." Instead: AI does the typing. You do the thinking. The concept is vibe engineering.

**Sam:** Vibe engineering. Define it.

**Maya:** You're using agents to code all the time, but you just look at your screen like, I'm going to catch you. You're using them, you're not trusting them.

**Sam:** I like that, because it respects the senior. Their job was never the typing.

**Maya:** It respects their expertise, it requires skepticism, which is what they already have, and it amplifies instead of replacing. They're still the engineer. They're just faster.

**Sam:** So the reframe is, AI isn't trying to replace you, it handles the parts you didn't want to do anyway.

**Maya:** The boilerplate. The same pattern for the hundredth time. Seniors want to solve problems, not type. AI handles the typing. Seniors handle the judgment.

**Sam:** Alright, tactically. I'm a manager Monday morning. Where do I start?

**Maya:** Start with tedious tasks, not core architecture. Writing tests for existing code, generating docs, boilerplate, adding error handling to happy-path code. Low stakes. If the AI gets it wrong, who cares, you were going to review it anyway.

**Sam:** And then let them watch it fail.

**Maya:** This sounds backwards, but seeing the AI make a mistake and catching it builds trust. Success looks like luck. Catching failure looks like control.

**Sam:** What about the urge to mandate it?

**Maya:** Don't. Provide escape hatches. "We've set up the tool for the team. Use it if you want, don't if you don't." Seniors adopt when they choose to. And when one tries it and gets value, they tell the others. That beats any training session.

**Sam:** Give me the one move for first thing tomorrow.

**Maya:** Pick your most skeptical senior, the one who rolls their eyes at AI hype. Ask what they hate doing. Not what's hard, what's tedious. Then suggest AI for just that one thing. Point it at that test file, ask it to add edge case tests.

**Sam:** And let them stay skeptical.

**Maya:** Don't oversell. "Try it. If it sucks, you've lost thirty minutes." And when they catch a mistake, celebrate it. "Good catch. That's why we need someone who knows what to look for." You're not converting everyone today. You're creating one positive experience.

**Sam:** One senior who thinks, actually, that saved me time.

**Maya:** That person becomes your internal advocate. Your juniors accept AI output without questioning it, and that's the problem. Your seniors question everything, and that's the asset.

**Sam:** This has been Pilot to Production, from the Growth Project. If your seniors are skeptical of AI, good, that skepticism is the asset, and building it into real adoption is the work we do at thegrowthproject.com.

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