What is vibe coding?

You describe what you want in plain English and an AI model writes the code. That is vibe coding.

You say "build me a habit tracker with a weekly streak" and working code comes back. You run it, something is off, you say what is off, and it gets patched. Andrej Karpathy gave the thing its name in early 2025, half joking, and it stuck because a lot of people realised they were already working this way and just had not called it anything.

The smallest possible version looks like this:

You:   "Make me a to-do app."

Model: function addTask(text) {
         tasks.push(text)
       }

Why it took off

Two things happened around the same time. The models got good enough that the code they write usually runs, and the tools around them turned a single prompt into a conversation. So instead of pasting code out of a chat window, you sit in a loop: describe something, watch it get built, complain about what is wrong, repeat. For a small project the distance between "I have an idea" and "it works on my screen" went from days to somewhere under an hour, sometimes minutes.

That loop is really the whole thing. Whether it feels like magic or like babysitting depends on the day.

What a real session looks like

The to-do app example undersells it, so here is a more honest picture of an afternoon of vibe coding.

You start with something like "I want a page where my team can paste a job posting and get back a checklist of requirements." The first version comes back and it works, roughly. The layout is odd and it silently fails on long postings. So you say that. The layout gets fixed in one round. The long-posting bug takes three rounds, because the model keeps fixing a different thing than the one you meant, until you paste the exact error message and it clicks.

An hour in, you have a working internal tool that would have taken a week to get prioritised, let alone built. You also have a nagging feeling that you should ask someone technical to look at it before the whole team relies on it. Both halves of that experience are typical, and the second one matters as much as the first.

The tools, roughly grouped

The specific products change month to month, but they fall into three groups that have stayed stable.

Chat assistants are the entry point: you describe, they answer with code, you paste it somewhere and come back with problems. Coding agents go a step further and live inside an editor or a terminal, reading your files and making changes directly, which removes most of the copy-paste. App builders go furthest: you describe a product and get a running, hosted app with a database behind it, no code visible unless you ask.

Which group you use matters less than people think. The working style is the same in all three: describe, review, correct. The skill that transfers is on your side of the conversation.

What it is not

The model writes with total confidence whether it is right or wrong, and it is wrong more often than the confident tone suggests. Someone still has to notice. The comparison that fits best in my experience is a very fast junior developer who never gets tired and never says "I'm not sure": brilliant for a weekend project, risky for anything with real users or real money unless a human is actually checking the work.

The failure modes are specific enough to name. The model will build the thing you literally asked for instead of the thing you meant. It will quietly invent a function or setting that does not exist. It will fix the bug you pointed at by introducing one you did not. And it handles security the way an eager junior does, which is to say it does not, unless someone asks. None of this makes the approach useless. It makes review the job.

Who is actually doing it

The early adopters were developers, but the interesting spread has been everywhere else. Product managers build working prototypes instead of writing specs about them. Designers turn mockups into clickable demos without waiting for an engineering slot. Analysts write one-off scripts to clean data they used to wrangle by hand. Founders with no technical background stand up a first product themselves and defer hiring an engineer by months.

For those people vibe coding works as access to something that used to be gated behind years of syntax. The gate that remains is judgment, and it turns out that gate was always the real one.

What it actually changes

Typing was never the interesting part of building software, but it used to be the time-consuming part. Now it mostly isn't. What is left over is the part that was always harder to hire for anyway: knowing what to build, and being able to look at a result and tell whether it holds up.

So the skills that pay are drifting. Syntax recall is worth less than it was. Being able to describe a problem precisely, and to spot a bad answer dressed up as a good one, is worth more. People who know what good looks like get a lot out of these tools. People who can't tell yet mostly generate plausible-looking problems for later.

The same pattern is spreading beyond code into ordinary knowledge work, where it gets called vibe working: the tool produces the draft, the analysis, or the plan, and the human's job shifts to direction and review.

What this means for your skills

If you work anywhere near software, some of your current skills just got cheaper and some got more valuable, and it is genuinely hard to see from inside a job which is which.

If you are technical, the valuable end is moving toward architecture, review, and the ability to specify problems well. If you are not technical, the door to building things just opened, and the skill worth developing first is evaluation: knowing what good output looks like in your domain, because that is what separates people who ship useful tools from people who ship confident bugs.

Where do your skills stand? Run the free career check and see which of your technical and judgment skills carry over to the roles hiring now, and which gaps are worth closing first.

Vibe coding is one instance of a pattern that keeps repeating: tools absorb the mechanical part of the work and the value moves to judgment. Worth knowing where you sit in that before the next round of it arrives.