5 very different ways of "vibe coding"

"Vibe coding" was coined by Andrej Karpathy long ago in an era nearly forgotten by all, before the things in the world had names, before we knew ourselves, before the sun came up for the first time, before God separated the lands from the seas... all the way back in February 2025:

Ok maybe it's not that long ago. But at the speed AI[footnote]I can't believe some people still think it's "plateauing"...[/footnote] moves, it might as well be.

I like the term "vibe coding". Some people hate it. One of the biggest problems with it, though, is it means very different things to different people.

I see at least four ways that I use the term myself, to refer to very different behaviours. All of which fit the term in my mind, to some greater or lesser degree. And a fifth one that, as a programmer for over three decades, I don't really use yet, but which is also worthy of the term, if only because it's likely to be the future of software development.

They each have pros and cons, their safe use depends on our level of skill, and when they get all blended together communication is impossible. So let's break them down for clarity.

1 - Vibe Coding First Form: Vibe tabbing

I love neovim, but Cursor's auto tabbing is second to none at this point. It doesn't always get it right, but it does often enough that it makes a big difference to my productivity.

Yes, DHH is right that the code that is produced this way is often boilerplate that should be eliminated rather than made easier to vomit out into the codebase. But not always. Often, it's just a neat, proven implementation of something that would otherwise take me some precious brain space to think about.

It takes a lot less work for me to glance through the vibe-tabbed code and decide if it's fit for purpose, and maybe make some minor adjustments. And that saves me a lot of time and, more importantly, brain space, for more interesting matters than remembering the exact property names that I need in order to do this specific small task like pulling the list of Whatevers and sorting it by Thingamajigs.

Vibe tabbing doesn't teach us much, but it does save us time, if we know what we're doing. If we can't quickly, unerringly evaluate the code it produces, though, my suggestion would be to turn it off and learn to do all this unassisted, otherwise it will introduce as many bugs as it fixes, and they'll all be quite subtle because they all look right.

2 - Vibe Coding Second Form: Vibe Fixing

Many IDEs and editors, NeoVim and Cursor included, now have a function that enables you to select a bit of code that isn't doing what you want, and fix it.

About 90% of the time I find this useful to figure out the tailwind syntax for centering something in a div[footnote]How does tailwind manage to have nine ways of placing things inside divs? place-self-center, place-items-center, place-content-center, self-center, items-center, content-center, justify-self-center, justify-items-center, justify-center???[/footnote]. Sue me.

This is also super helpful to avoid having to waste minutes hunting down for a simple thing that the AI can recall instantly, or, if I've asked a ChatGPT window how to do it, having to work out how to apply ChatGPT's advice.

This is again a time-saver, and also one that requires us to be able to quickly evaluate the output of the AI, because sometimes it goes wildly off course. But it doesn't teach very much. It relies on our current skill level and doesn't get us any better.

3 - Vibe Coding Third Form: Vibe Agenting

We're now getting closer to Andrej Karpathy's original meaning of the term, and what he was originally pointing at.

Originally, I first encountered this method in its full splendour in Windsurf with its "Cascade" approach which took off a lot of the guardrails that the step by step semi-agentic mode in Cursor had presented us with. I was amazed when I told Windsurf to make a given screen look better, and, a minute or two later, it had rearranged the html to make it look nice and professional-enough, freeing me to do something else.

Since then, Cursor caught up with Windsurf and basically terminated it, and then was trounced (for many) by the superior features of Claude Code, which imho is the de-facto platform to use if you're serious about vibe coding with agents (also because it opens up the 4th form, which no others do). And of course Codex is nipping at Claude Code's heels quite well too.

Vibe Agenting can let us get away with not really knowing what we're doing... for a time. Inevitably, at some point, the agent starts eating its own tail, gets stuck in a loop of nonsense where it's trying to solve some minor bug with increasingly disruptive solutions. There are ways to stop it doing anything truly destructive, but we can't stop it deciding to rewrite half our app and install a bunch of unnecessary libraries in order to fix a bug that it was too dumb to figure out (or that just isn't worth fixing for that level of effort)[footnote]And, if used via Cursor, it will happily eat up hundreds of dollars' worth of tokens doing this... Friends don't let friends pay for Cursor credits. Use Claude Max or OpenAI Pro.[/footnote].

That said, Vibe Agenting can go quite far. It's extremely good at fixing specific bugs. When I get a stack trace on Honeybadger, I just pass the error ID to Claude Code, it uses the honeybadger MCP to get the trace, and then explains the issue and proposes a fix[footnote]In case you want it, here's the Claude Code command I use.[/footnote]. I review that, approve the solution if it's not brain-dead, and, bingo, the bug is fixed and a new test is added to prevent it from happening again, all while I go make a coffee.

It's also very good at re-applying patterns that already exist. "Make this list lazy-loaded like the list in this other view" works a treat and saves me a bunch of hassle each time.

But it has some serious limitations, and if we aren't skilled enough to delve into the code and fix it when the AI inevitably fails, this way is still doomed to produce a non-working application sooner rather than later. And it can be quite hard to learn from Vibe Agenting, though using Claude Code's learning output style can help (at the cost of a substantial slow-down).

Vibe Agenting will only get us so far (limited by our current skill level) and will probably not substantially help us get beyond our own limitations.

But there is another way.

4 - Vibe Coding Fourth Form: Vibe Pairing

I detailed this in this article, so I won't go into too much detail into it.

The essence is, in this model, we invoke the AI (currently only Claude Code, I believe) to become a coding mentor and help us design better apps.

Like all mentors, ClauDHH (or whoever else you decide to invoke to teach you how to code better) is still fallible, and so we can't always take all its suggestions at face value. But with this approach, learning is supercharged.

For all the Forms of Vibe Coding except the last one, the main limitation for how well we can leverage the AI to speed up is our own experience and skill, but they don't do a whole lot to improve those. In fact, they probably take away from our learning curve, by providing easy shortcut that require little or no thinking unless something breaks (and when it inevitably does, we're thrown it at the deep end, and most people sink then).

But this one - this one is different. At least for me, it has been. For the first time in many years, I am learning rapidly. And I don't mean learning yet another framework or language.

After 3 decades of programming, languages and frameworks feel mostly interchangeable. Tell me that I need to program something in Rust tomorrow and I'll spend a couple of hours reading about the Rust syntax and probably do a passable job by tomorrow[footnote]Aided by my fairly substantial experience with C in my teens[/footnote]. Demand of me to work on a React app and, having never really done so, I'll probably do alright with it within a couple of hours.

But getting better at the craft of software engineering is another matter entirely. Normally, this comes from two things: experience[footnote]When we hit the obstacles head on for ourselves and learn the hard way.[/footnote], which is slow, and mentoring[footnote]When a much more experienced programmer shows us how we can work with the language and framework rather than fighting it, and we feel a sense of lightness and freedom as we finally figure out how to do things the light and elegant way.[/footnote], which I've not had much of in my own programming life, and which many solo developers operating in today's world may never ever encounter.

Except that now we all can get a solid mentor, whether it be ClauDHH or some other inspiring programming figure. Just prime the AI to behave as closely as possible to this mythical figure, ask it to review your code, your specs, your requirements, and I can practically guarantee that you will start learning very rapidly.

This will then also improve your ability to make use of the other three Vibe Coding Forms, and massively grow your capability as a developer.

Oh, and about that fifth form...

5 - Vibe Coding Fifth Form: Vibe Doing

Ultimately, almost all of the programming referred to in this article is an aberration, a temporary glitch while AI gets good enough to not need any "coding" whatsoever.

Right now, in its more complicated form this looks like platforms like Loveable and Replit, which claim to enable us to launch apps to the public, and can definitely help launch prototypes, but are probably not a good idea to use for a production app we intend to scale. In the simpler forms, it looks like Claude Artifacts, mini-React-apps that Claude builds to solve a specific problem.

This future is coming fast[footnote]I think it will start becoming a major form of human interaction with the web by the end of next year, and start seriously decimating the ranks of software companies within three years[/footnote] but it's still in its infancy. Ultimately, the interface for it is not an app like Loveable where we have to tell the AI to build an app to do a thing.

The ultimate interface for Vibe Doing is the same interface that billionaires around the world use to get things done: a butler (or, if you prefer, a personal assistant or chief of staff).

A billionaire looking to buy a yacht doesn't code an app to sort through yacht websites and rank them. They ask their butler to do it. The butler asks some questions, finds experts, does the search, and comes back with some choices and recommendations, and the billionaire makes their choice.

The future of human-computer interaction is the same. Some time in the not too distant future, when I want an app to keep track of which Mixcloud mixes I've listened to and cache them locally, I won't have to vibe-agent an app into life to do it (which is what I ended up doing for this specific case). I'll just ask my personal assistant to do it. And, if it decides that's worth it, it will whip up an app in whatever language it cares to use, code it up in a few minutes, and provide me with a nice simple interface that does what I want, or perhaps the interface will just always be to talk to my assistant. How the app is made won't matter to me, just that it does what I want, and if my AI is smart enough, it will do just that.

In this model, of course, learning about coding is irrelevant. It won't matter anymore. Neither will most currently valuable economic output.

But in the meantime... which programming guru will you invoke to become your mentor?