The Jordan-Karpathy Effect

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. Kobe Bryant is another recent example of a peak performer who often made the ridiculous look commonplace.

Now watch a 16-year-old try to “play like Mike”, or emulate Kobe Bryant or Steph Curry. They copy the tongue, the shrug, the fadeaway. 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

A junior developer handed an AI tool doesn’t have that foundation. Not because they’re incapable of developing it, but because they haven’t yet.

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.

Six months later, the codebase is unmaintainable. 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

Senior engineers are 3x, 4x, 10x more productive with AI than without it. Junior developers are often only marginally more productive, and sometimes less.

This is the Jordan-Karpathy Effect. The tool amplifies what you bring to it. Expertise gets amplified. The absence of expertise gets amplified too.

The same AI that turns a senior engineer into a one-person feature factory turns a junior developer into a fast producer of technical debt. Not because the AI is bad. Because the AI is neutral. It reflects the judgment 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.

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 numbers? They 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.