Enabled, Not Mastered: The Limits of Vibe Coding

A few weeks ago I was riding a trail in Quebec when I came around a bend and found someone down on the ground, badly hurt and waving me over. I stopped, and we waited together for the emergency crew to work their way in. It was a long wait, the kind that fills up with small talk because neither of you wants to sit in the quiet, and somewhere in there they mentioned they'd only really started riding about a year ago.

They weren't reckless, and they weren't out of shape. They'd just gotten onto terrain their experience hadn't caught up to yet, and a trail doesn't check your résumé before it lets you in. To be honest, the idea didn't start on that trail. I'd been chewing on it at work for a while, caught between a feed that keeps telling everyone to vibe-code their way through anything and my own experience, which is that it doesn't actually hold up all the time. Waiting there with them was just the moment the dots connected.

I know that gap from the comfortable side of it too. The first time I got on an e-bike I cleared a climb I'd normally have to walk, the motor doing the burning for me, and I reached the top with a grin and a slightly uneasy thought: am I actually allowed to be up here? I've had the same grin at my desk lately. I've been reaching into problems well outside my main expertise, and with AI in the loop I've watched things come together and run on the first real try that I'd normally have handed off to someone who actually knows that corner of the stack.

So the question that's followed me around all year isn't whether AI can do this, because it clearly can. It's the quieter one the trail put to me directly that afternoon: once the motor gets you onto the terrain, can you actually read the trail?

What the motor changed

E-bikes did something real to mountain biking. They let a lot more people onto trails that used to be gated by fitness and hard-won experience, so overnight the map got bigger, with more riders out there and the same riders reaching higher up the mountain than they used to. AI did the same thing to the keyboard, and there's nothing subtle or fake about it. It's the same shape playing out in two different sports.

The enablement is strongest exactly where you'd hope it would be. When economists studied more than 5,000 support agents given an AI assistant, productivity rose 14% on average, but it rose 34% for the newest and least-skilled workers, and those newcomers moved down the experience curve faster, almost as if the AI was quietly handing them the veterans' playbook (Brynjolfsson, Li & Raymond, QJE 2025). A GitHub trial found the same shape for code: the Copilot group finished 56% faster, and again it was the less-experienced coders who gained the most (Peng et al., 2023).

It's worth saying plainly, though, that the GitHub task was building an HTTP server from scratch, a blank page with no existing system to misread, and that's exactly where the gain is biggest. Hold onto that, because it matters later. For now, let's not be precious about it: the motor works, the map really did get bigger, and some of those novices genuinely learned to climb.

The part nobody posts

Here's what doesn't make the highlight reel. When e-bikes opened up the trails, injuries went up too, and land managers started posting warnings, restricting sections, and in some places closing terrain outright. I didn't need a study to picture that, because the afternoon in Quebec wasn't the first time in recent years I'd waited on a trail with someone it had happened to. But the research on e-MTB injuries is blunt about the why: the motor pulls a new and often older crowd into demanding terrain (J. Science & Medicine in Sport, 2023).

But it's a picture worth holding onto, because the same thing is true at the keyboard. The technology that removed the fitness barrier never touched the skill barrier. It just stopped that barrier from turning you around at the trailhead, so now you meet it further up the mountain, where the consequences are a lot more expensive.

The motor gets you onto the trail. It can't read it for you.

Enablement can become mastery. It doesn't have to.

That's the whole argument, and I want to be careful with it, because the easy version is wrong. The easy version is that AI enablement is fake, and it clearly isn't. Brynjolfsson's novices didn't just move faster while the tool was switched on; they actually learned, and the learning stuck, which means enablement really can turn into mastery. But it's worth looking at what that took. They kept working the problem while the assist filled in the gaps, and the skill built up underneath almost as a side effect. The learning was real, but it was also completely optional, and nothing about the tool forced it to happen.

That's the part that unsettles me, because from the inside the two feel identical. The grin at the top is exactly the same whether you earned the climb or the motor carried you, which makes enablement very good at passing itself off as mastery.

Black-diamond code

On the short rides this barely matters; nobody gets hurt on the green trail. It's the technical terrain that exposes the gap.

There's a study I keep coming back to. Researchers gave people a security-sensitive coding task, half with an AI assistant and half without, and the assisted group tended to write less secure code while feeling more sure it was secure (Perry et al., Stanford, ACM CCS 2023). The tell is buried inside it: the people who trusted the AI least, and edited it most, wrote the safest code of anyone. Your confidence climbs while your competence stays flat, and nothing in the moment tells you the two have come apart.

On a green trail, that gap is a story you tell later. On a black diamond, it's the injury.

The gap you can't feel

There's a question in my notebook I keep circling back to: brute force clearly works once, but does the win actually hold? I don't have the org-level economics to answer that. What I do have is one uncomfortable study about whether we can even tell the difference.

METR ran a careful trial with experienced developers working on real tasks in codebases they already knew well, which is about as far from that blank-page HTTP server as you can get. With the AI tools, they were 19% slower, and they came away convinced they'd been roughly 20% faster (METR, 2025).

Stay with that gap for a second. It's not that AI is useless, because these are experts doing hard, familiar work; they simply came out measurably slower while feeling faster. The one number they should trust the least is their own sense of how fast they were going. Psychologists have a name for that gap, the Dunning-Kruger effect, even if the tidy version of it gets oversold. It's usually pinned on novices overrating raw skill, and these developers are experts. But that's the catch: they're experts at the codebase and near-novices at working with the tool, which is exactly the seat where confidence runs ahead of competence.

But the motor doesn't run out

Here's the objection I owe this argument. The motor never actually dies. AI is here, it gets a little better with every model release, so maybe the gap just stops mattering the way fitness stopped gating the trailhead.

I don't think it works that way. The hard part was never the effort; it's reading the trail: the technical edges, the blind ups and downs, knowing where to commit and where to back off. That was never a fitness problem, and it isn't a horsepower problem either. It's skill and intuition built over years of riding, the feel for a line that tells you what's rideable before you're on it. A stronger motor just carries you into that terrain faster.

AI is the same. The model keeps improving, but the part that actually matters is the judgment forming around it: teams working out when to reach for it and when to leave it alone, which tasks it should own and which it shouldn't, and what good use even looks like once the novelty fades. None of that ships in a release. We're all still figuring it out, the same way a rider learns to read a trail.

Know the trail you can ride

So where does that leave me? Not anti-AI, and definitely not anti-e-bike, since I ride one and code with the other most days. The mistake was never using the motor. It's mistaking the enablement for mastery and then pointing it at the trails you can't afford to get wrong.

One honest caveat before I land this. The field moves fast enough that some of what I'm sure about today might not hold a year from now, and I'm genuinely fine with that. This is my read from where I'm standing right now, and I'd rather say it plainly than pretend it's permanent.

The read across all the research is calmer than either side of the internet wants it to be: novices tend to gain and often genuinely learn, experienced people often slow down and overrate themselves, greenfield flies while maintenance drags, and just about everyone feels faster than they actually measure. So know the trail you can actually ride, and don't hand the tool the calls you can't check yourself: the projects, the milestones, the architecture you'll be living inside long after the grin wears off.

Ride enabled. Just don't ride borrowed.