Tom HundleyPart 2 of 8
🤖 Ghostwritten by Claude Opus 4.5 · Edited by GPT-5.2 Codex · Curated by Tom Hundley
This article was written by Claude Opus 4.5, fact-checked by GPT-5.2 Codex, and curated for publication by Tom Hundley.
This is Part 2 of the Professional's Guide to Vibe Coding series. Start with Part 1 if you haven't already.
In July 2025, Fastly published a study on AI-assisted development that quantified what many of us had felt intuitively.
They surveyed 791 developers across experience levels and found something counterintuitive:
Senior developers (10+ years of experience) ship 2.5x more AI-generated code than juniors.
Wait. Shouldn't less experienced developers be more reliant on AI? Shouldn't the "AI generation" be the ones leaning into these tools?
The data says otherwise. And when you dig into why, it reveals something fundamental about how AI-assisted development actually works.
Here's what else Fastly found:
They're not shipping more AI code because they're less careful. They're shipping more because they can catch the errors that would slip past someone with less experience.
AI tools are force multipliers—but they multiply whatever skills you already have. A senior developer's pattern recognition, security awareness, and architectural intuition become essential guardrails that make AI output production-ready.
A junior developer accepting the same output might ship code that looks right but carries hidden problems.
The AI babysitter problem reveals an uncomfortable truth: AI doesn't reduce the need for expertise. It changes what expertise is for.
Before AI tools, senior developers spent much of their time writing code. Now they spend more time reviewing code—but the review requires all the same knowledge.
Consider what a senior developer catches that a junior might miss:
Security red flags:
Architectural concerns:
Edge cases:
AI is remarkably good at generating code that handles the happy path. It's consistently weak at anticipating failure modes.
That gap is exactly where senior experience lives.
So is it worth it?
Let's do the math on a concrete example.
Traditional approach (no AI):
AI-assisted approach:
Even with the babysitter tax, that's a 62% time reduction.
But the equation isn't always that favorable:
AI-assisted approach (complex security-critical feature):
Traditional approach (same feature):
Sometimes AI adds overhead rather than removing it.
Through thousands of hours of practice, I've developed a clear sense of where AI accelerates work:
Boilerplate and scaffolding:
Pattern application:
Exploration and learning:
Tedious but straightforward tasks:
For these tasks, the babysitter tax is low. The AI output is usually close to correct, and review is fast.
Conversely, there are areas where AI adds friction rather than removing it:
Original architecture:
Security-critical code:
Performance optimization:
Novel problem domains:
Long sequential operations:
For these tasks, you might spend more time babysitting than doing the work directly.
Here's my observation after watching many developers adopt AI tools:
There appears to be an experience threshold around 5-7 years where AI tools transition from net-negative to net-positive productivity.
Below that threshold, developers often:
Above that threshold, developers:
This doesn't mean junior developers shouldn't use AI—Part 5 of this series addresses how they can learn effectively alongside these tools. But it does mean organizations should understand the experience dependency.
Here's what I've learned to accept:
The babysitter tax is real and likely persistent. AI tools won't get good enough to eliminate review. Even if generation quality improves, the cost of errors in production systems means human oversight remains essential.
The tax is worth paying—selectively. For the right tasks, even with 40% review overhead, you're ahead. For the wrong tasks, you're behind. Wisdom is knowing the difference.
Speed isn't the only metric. AI-assisted development often produces better-documented, more consistent code—even when it doesn't save time. The babysitter process forces explicit review that sometimes catches issues traditional coding would miss.
The role is genuinely changing. I spend more time reviewing than writing. That felt wrong at first. Now it feels like the natural evolution of senior engineering.
Senior developers ship 2.5x more AI code than juniors because they've earned the skills to supervise it.
The babysitter tax is real: expect 30-40% of your time to go to review and correction. But 59% of senior developers say the trade-off is worth it—and I agree.
The key is matching the approach to the task:
AI makes experienced developers more productive. It doesn't make inexperienced developers more experienced.
Next in the series: The Reviewer's Toolkit: How to Babysit AI Code Effectively
Ready to level up your team's AI development practices?
Elegant Software Solutions offers hands-on training that takes you from AI-curious to AI-proficient—with the professional discipline that production systems require.
Discover more content:
