Vibe coding used to be funny

In February 2025, Andrej Karpathy posted a tweet that would mint a new term for an entire generation of developers. He described "vibe coding" as a way to "fully give in to the vibes, embrace exponentials, and forget that the code even exists." People laughed. It sounded like a joke, like a senior AI researcher admitting he'd given up on reading diffs. The tweet got 4.5 million views and the replies were full of memes. That was funny. What's less funny is that in 2026, almost everyone is doing it.

The joke became the job

Vibe coding started as a novelty. Karpathy himself later called it a "shower thoughts throwaway tweet." But the term stuck because it named something real, something a lot of developers were already feeling. The LLMs were getting good enough that you could describe what you wanted, hit accept, and move on. By the end of 2025, Collins English Dictionary named "vibe coding" their Word of the Year. It had its own Wikipedia article, its own subreddit, its own economy. The industry that grew around it hit $6.6 billion. What began as one person's weekend experiment became the default way millions of people build software. And here's the thing nobody wants to say out loud: we can't really review this code anymore.

The review problem

A 10,000-line pull request generated by an AI agent lands in your inbox. You're supposed to review it. But reviewing AI-generated code isn't like reviewing a colleague's work. When a human writes code, you can follow their reasoning. You can see patterns that match how they think. AI-generated code doesn't think. It produces plausible output, and plausible output is the hardest kind to audit. LinearB's 2026 Engineering Benchmarks Report found that AI-assisted pull requests merge at less than half the rate of human-authored code. Not because the code is always worse, but because reviewers can't keep up. Jellyfish's data shows AI-adopted teams push PRs that are 18% larger on average. CodeRabbit's analysis found AI-generated code has roughly 2x more naming inconsistencies, 8x more excessive I/O operations, and unpredictable quality spikes that make trust-based review impossible. The old model of code review assumed a human wrote the code and another human could follow the logic. That assumption is breaking. You can't skim AI code the way you'd skim a senior developer's work, because AI doesn't have a consistent level of competence. Every line needs verification, and nobody has the mental capacity for that at scale. So what happens? People stop reviewing. If it works, it works.

If it works, does the code matter?

This is the uncomfortable question at the center of vibe coding in 2026. If the app runs, if the tests pass, if the users are happy, does it matter that nobody fully understands the codebase? For a weekend project, probably not. For a startup trying to ship fast, maybe not right now. But the debt is accumulating. Developers on Reddit describe losing control of their own codebases. One post titled "Vibe Coding is Ruining My Life" describes the feeling of being trapped: "Without the AI, I never would have built something this complex, but now I'm trapped by it." The code works, but it's a black box. When something breaks, you're debugging output you never wrote and don't fully understand. The counterargument is that this has always been true at some level. Nobody reads every line of their framework's source code. Nobody audits every dependency. We've always operated on layers of trust. Vibe coding just makes that trust more explicit, and more uncomfortable.

The new abstraction layer

Here's where the historical pattern gets interesting. Every major shift in programming has been a move up the abstraction stack. Machine language was replaced by assembly. Assembly was replaced by C. C was replaced by higher-level languages like Python and JavaScript. Each transition followed the same script: the old guard said the new approach was wasteful, imprecise, or dangerous. And each time, the new abstraction won because it let more people build more things faster. No-code tools were supposed to be the next layer. Drag-and-drop builders that let non-developers create applications. They worked for simple use cases, but they hit a ceiling. You could build a form or a basic workflow, but anything complex required dropping back into real code. Vibe coding is what no-code always wanted to be. The abstraction isn't visual components or drag-and-drop interfaces. The abstraction is language itself. You describe what you want in English, and the machine figures out the implementation. Python was a higher-level abstraction over C. English is a higher-level abstraction over Python. This isn't a metaphor. It's literally what's happening. Just as C programmers once looked at Python and called it a toy, experienced developers look at vibe coding and call it reckless. And just as Python didn't replace the need to understand computing fundamentals (it just changed which fundamentals mattered most), vibe coding won't eliminate the need for engineering judgment. It'll change what engineering judgment looks like.

The abstraction always wins

Every previous abstraction layer expanded who could build software and what they could build. Assembly made hardware accessible to more than electrical engineers. C made systems programming accessible beyond assembly specialists. Python made programming accessible to scientists, analysts, and hobbyists. Vibe coding is making software creation accessible to anyone who can describe what they want. The pattern from history is clear: lowering the cost of doing something doesn't reduce demand for it. It expands what's possible. But here's the part the optimists gloss over. Every abstraction also introduced new failure modes. Higher-level languages traded raw performance for productivity. Managed memory traded control for safety. Cloud computing traded ownership for convenience. Each layer gained something and lost something. Vibe coding trades understanding for speed. You get software faster than ever before, but you may not know how it works. And when abstractions leak (and they always do), someone needs to understand the layer below.

What comes next

The developers who thrive in this era won't be the ones who refuse to use AI, and they won't be the ones who blindly accept everything it produces. They'll be the ones who understand what the abstraction is hiding and know when to look underneath. Karpathy himself seems to have moved on. Recent writing suggests he's already thinking about what comes after vibe coding, what he calls "software engineering" as distinct from "coding." The idea is that the coding part gets automated, but the engineering part (understanding systems, making architectural decisions, managing complexity) remains fundamentally human. Maybe that's right. Or maybe the next abstraction will handle that too, and we'll look back at 2026 the way we look back at people who insisted real programmers write assembly. Either way, vibe coding isn't a joke anymore. It's just how we build now.

References