Andrej Karpathy coined the term “vibe coding” to describe something real: the best developers using AI aren’t thinking step-by-step through every line. They’re feeling the shape of the solution, directing the AI fluidly, and iterating fast. It looks effortless.
It isn’t.
The Jordan Effect
Watch Michael Jordan play in his prime and you see someone who makes basketball look like instinct. He reads the defense before it forms. He knows where the open man will be. His shots look effortless. He reacts and moves at a speed that seems to be beyond thinking.
That’s not the absence of thinking. That’s thinking that’s been internalized so deeply it no longer requires conscious effort. Thousands of hours of deliberate practice, compressed into something that looks like flow.
You can see the same with Steph Curry. His shots rain from impossible places on the court and he just smiles. Effortless, it seems.
Now watch a 16-year-old try to “play like Mike” or shoot like Curry. They copy the tongue, the shrug, the fadeaway, or the deep three. The form without the foundation. It doesn’t work, because you can’t fake the foundation.
We’re watching the same thing happen with AI-assisted development.
What Karpathy’s “Vibe” Actually Means
When a senior engineer vibes with an AI, they’re operating from a foundation:
- They know what good architecture looks like. The AI proposes something. They know immediately if it fits.
- They have internalized standards. Clean code, SOLID principles, DRY. They don’t consult a list. They recognize violations.
- They understand the tradeoffs. Speed vs. maintainability. Abstraction vs. readability. They’ve made these calls a thousand times.
- They know when to stop the AI. They can see the moment a generated solution is heading somewhere wrong.
The vibe is the fluency of expertise, not the abandonment of it.
The AI is a fast instrument. They’re the musician.
What Happens When You Don’t Have the Foundation
An inexperienced developer handed an AI tool doesn’t have that foundation yet. Not because they’re incapable of developing it, but because they haven’t had enough time, enough reps, or enough feedback.
They prompt the AI and accept the output. The code runs. The tests pass (because they let the AI write the tests too). It ships.
Months later, the risk shows up. Nobody can explain why the architecture looks the way it does. Adding a feature requires understanding a system nobody designed intentionally.
The AI didn’t write spaghetti code. The lack of standards did.
The junior developer wasn’t lazy. They were using the tool the only way available to someone without the internalized judgment to use it differently. They vibed. They just didn’t have anything to vibe from.
The Productivity Gap Makes Sense Now
At a marketing services SaaS provider, two developers recently built a data-comparison tool. It runs automatically to evaluate the fitness of certain pieces of information for each customer. In the past, I would have expected a tool like that to take the better part of two weeks to create, test, and prepare for production.
They delivered it in three days.
That is the Jordan-Karpathy Effect. The tool amplifies what you bring to it. When developers have the context, standards, and judgment to direct AI well, the productivity gain is real.
Less experienced developers can still get speed from AI. What they may not get is direction. Without standards, the same speed can produce code that works today and becomes expensive tomorrow. Not because the AI is bad. Because the AI is neutral. It reflects the judgment and constraints of the person directing it.
What This Means for Leaders
The wrong response to this is to restrict AI access for junior developers. That’s the old “wait your turn” model of development, and it’s going to leave your team behind.
The right response is to close the gap deliberately.
Junior developers need explicit standards. Not taste, not intuition, not “you’ll know it when you see it.” Measurable, documented, reviewable standards. When you make the implicit explicit, juniors can learn from reviews, apply feedback systematically, and build the foundation faster.
Set the expectation. Don’t just give them the tool. Give them the framework for using it deliberately: review the code, understand the patterns, measure against standards. The vibe comes later. The foundation comes first.
And here’s something available to leaders right now that didn’t exist before.
Your AI follows instructions.
Write them.
Your years of architectural judgment, your heuristics for what good looks like, your standards for clean code and sustainable design: put them in the instructions file. The CLAUDE.md. The copilot-instructions.md. Whatever entry point your team uses.
When a junior developer runs an AI agent with your standards loaded, they’re not vibing at their own level. They’re vibing at yours. The AI keeps them on the rails you built. It flags patterns you’d reject in a code review. It enforces conventions you spent years developing.
At the same marketing services SaaS provider, the legacy codebase had no unit tests when I arrived. After adding Copilot instructions, new work began producing unit tests automatically because the standards made that expectation explicit. In the newer codebase, we now have thousands of tests that were added automatically through AI-assisted development.
The same thing shows up in architecture. New code generated with our instructions regularly scores sixes and sevens on the code scorecard for architecture. The point is not that the AI suddenly developed taste. The point is that it was given the standards, patterns, and expectations it needed to produce better work.
This is a new form of knowledge transfer. For over fifty years, the only way to share your expertise with a junior was to sit next to them, review their code, and explain your reasoning one line of code at a time. Now you can encode that reasoning into the system. Your experience becomes the junior’s operating environment from day one.
You can help your juniors vibe at your level. That’s not a metaphor. That’s a feature.
The Floor Is Rising
The Jordan-Karpathy Effect isn’t a ceiling. It’s a gap that can be closed.
Karpathy didn’t vibe from nothing. He built the foundation first. Jordan didn’t shrug and shoot until the mechanics were automatic. The path to effortless is through deliberate.
The senior engineers posting massive productivity gains didn’t skip the foundation. They built it over years, and now AI has made it compound.
Your juniors can get there. But they need the foundation, not just the tool.
Give them both.
Receipts
- Data-comparison tool: At a marketing services SaaS provider, two developers built and tested a production-ready data-comparison tool in three days. I would normally have expected that work to take the better part of two weeks.
- Testing instructions: In a legacy codebase that had no unit tests when I arrived, Copilot instructions now cause new work to include unit tests automatically.
- New codebase test coverage: In the newer codebase, AI-assisted development has added thousands of tests under the team’s coding instructions.
- Architecture scoring: New code generated with the team’s instructions regularly scores sixes and sevens for architecture on the code scorecard.