What is vibe coding? Karpathy's term, explained
Vibe coding means building software by prompting an AI and accepting its code without reading it. Where the term came from, when it works, and where it breaks.

Vibe coding is building software by describing what you want to an AI model, accepting the code it writes without reading it, and steering only by whether the result seems to work. Andrej Karpathy coined the term in a post on February 2, 2025, and the defining trait is the missing review: if you read, test and understand the code, it’s AI-assisted programming, not vibe coding.
Where does the term “vibe coding” come from?
Karpathy’s original post describes “a new kind of coding I call ‘vibe coding’, where you fully give in to the vibes, embrace exponentials, and forget that the code even exists.” He was using Cursor Composer with Claude Sonnet, talking to it through a voice tool, and he listed the habits plainly: he hits “Accept All” always, doesn’t read the diffs anymore, pastes error messages back in with no comment, and when a bug won’t go away he works around it or asks for random changes. He closed with the scope: “It’s not too bad for throwaway weekend projects.”
That last line gets dropped a lot. The term spread fast enough that Collins Dictionary named “vibe coding” its Word of the Year for 2025, describing it as “the use of artificial intelligence prompted by natural language to write computer code.” That definition is broader than Karpathy’s, and the gap between the two is where most of the confusion lives.
What is the difference between vibe coding and AI-assisted coding?
Simon Willison drew the line in March 2025, in a post titled Not all AI-assisted programming is vibe coding. His definition: vibe coding is building software with an LLM without reviewing the code it writes. If you review it, test it and can explain it to someone else, you’re doing software development, and whether an LLM typed it doesn’t matter.
His golden rule for production code is the one I use: “I won’t commit any code to my repository if I couldn’t explain exactly what it does to somebody else.”
So the test isn’t the tool. Two people can sit in the same editor with the same model and the same prompt. One reads every diff, runs the tests and asks why a dependency was added; the other clicks Accept All. Only the second one is vibe coding. Collins’ broader definition would call both of them vibe coders, which is why I’d stick to Karpathy’s sense when the word matters, such as in a code review policy or a hiring conversation.
The opposite pole is spec-driven development, where you write down intent and acceptance criteria before the agent writes anything. Between the two sits most real work: an AI coding agent does the typing, and a human reviews, tests and decides what ships.
Why does vibe coding work at all?
Because the models got good enough that “it mostly works” became true for small programs. A single-file tool, a personal dashboard, a script that renames photos: these have few moving parts, the feedback loop is the program itself, and when it breaks the cost is a lost evening.
There’s also a learning argument, and Willison makes it: vibe coding lets people who can’t program build tools for themselves, and it teaches experienced developers what the models can and can’t do. I find the second point underrated. The fastest way to calibrate your trust in a model is to let it run unsupervised on something that doesn’t matter and watch where it goes wrong.
Where does vibe coding break?
The failure modes follow directly from not reading the code.
Secrets end up in the source. A model asked to “make it call the API” will often paste the key straight into the file. If you don’t read the file, you commit the key.
Costs and rate limits. Willison’s list of cautions includes being careful with usage-billed APIs that have no spending limit, and not hammering other people’s services. Generated code that loops over a list and calls an API per item, with no backoff, is a pattern I’d expect from any model asked for the quickest working version.
Data you don’t own. Code that touches personal data carries obligations the model knows nothing about. Coming from data platforms and privacy compliance work, this is the line I’d circle: you can’t meet a retention or deletion requirement in code you’ve never read.
Bugs you can’t fix. Karpathy’s own description says the code “grows beyond my usual comprehension.” That’s fine until the model can’t fix a bug, at which point nobody can, quickly. The workaround he describes, asking for random changes until the bug goes away, produces code that is even harder to understand next time.
Does it make you faster? Less clear than it feels. METR ran a randomized controlled trial with 16 experienced open-source developers on 246 tasks in projects they knew well, using early-2025 tools (mostly Cursor Pro with Claude 3.5 and 3.7 Sonnet). Developers predicted AI would cut completion time by 24%, and afterwards estimated it had cut it by 20%. Measured, allowing AI made them 19% slower. That study isn’t about vibe coding specifically, and the tools have moved since, but it’s a good warning that the feeling of speed and the measured speed can point in opposite directions.
What does a safety net for vibe-coded code look like?
If you’re going to accept code without reading it line by line, put a cheap automated check between the model and your repository. Here is a minimal pre-commit gate that scans generated code for the risks above. It’s deliberately small; real tools such as secret scanners do this better, but it shows the idea.
# vibe_gate.py: a pre-commit gate for code you did not read line by line.
# Python 3 standard library only. Flags the risks Simon Willison lists for vibe coding.
import re
GENERATED = '''
import requests
OPENAI_API_KEY = "sk-proj-4f9a2c7e1b8d4e6f9a0b1c2d3e4f5a6b"
DB_URL = "postgres://admin:hunter2@10.0.0.5:5432/prod"
def fetch_all(user_ids):
for uid in user_ids: # no rate limit, no backoff
requests.get(f"https://api.example.com/users/{uid}")
def run(cmd):
import os
os.system(cmd) # shell string built elsewhere
'''
RULES = [
("secret", r"""(?i)(api_key|secret|token)\s*=\s*["'][A-Za-z0-9_\-]{16,}["']"""),
("secret", r"\w+://[^:\s]+:[^@\s]+@"), # credentials inside a URL
("shell", r"\bos\.system\(|shell\s*=\s*True"),
("network", r"requests\.(get|post)\(.*\)"), # outbound calls: who pays, who rate-limits?
]
for n, line in enumerate(GENERATED.splitlines(), 1):
for kind, pattern in RULES:
if re.search(pattern, line):
print(f"line {n:>2} [{kind:<7}] {line.strip()[:60]}")
Output (Python 3.13.11):
line 3 [secret ] OPENAI_API_KEY = "sk-proj-4f9a2c7e1b8d4e6f9a0b1c2d3e4f5a6b"
line 4 [secret ] DB_URL = "postgres://admin:hunter2@10.0.0.5:5432/prod"
line 8 [network] requests.get(f"https://api.example.com/users/{uid}")
line 12 [shell ] os.system(cmd) # shell string built elsewhe
The key and the database password are fake. The point is what a gate like this changes: you still don’t read every line, but the lines most likely to hurt you get pulled in front of you. The same idea scales up into the verification half of harness engineering: tests, linters, scanners and sandboxes that check the agent’s work so you don’t have to read all of it.
Is vibe coding good or bad?
Neither; it’s a mode, and the mistake is using it outside its scope. Karpathy’s own scope was throwaway weekend projects. Willison’s cautions are about stakes: keep it low-stakes, watch for secrets, don’t run up bills, don’t burden other people’s services.
My take is that the useful question for any piece of software is “who pays if this is wrong?” If the answer is “me, a little,” vibe code it. If the answer includes users, customers, a compliance team or an on-call engineer, someone has to read the code, and an AI that wrote it fast doesn’t change that.
What I would do
- Vibe code prototypes, personal tools and throwaway experiments. Use the speed. Keep them out of production repositories and away from real customer data.
- Draw the line at the commit. Anything that goes into a shared repository passes Willison’s rule: someone can explain every change. Code review policy should say this in plain words, because “the AI wrote it” will be offered as an excuse.
- Automate the checks you’d skip. A secret scanner, the test suite and a linter in pre-commit or CI. Run agents inside a sandbox with network limits, which I cover in sandboxing AI agents.
- Graduate a prototype by rewriting its intent, not its code. When a vibe-coded tool turns out to matter, write down what it does and what “correct” means, then rebuild it with review. That write-up is half of a spec.
- Measure, don’t feel. If a team claims AI made it faster, compare cycle time and defect rates before and after. The METR result is the reason I wouldn’t trust self-reports.
FAQ
Who coined the term vibe coding?
Andrej Karpathy, in a post on X on February 2, 2025. He described accepting all of an AI’s changes without reading the diffs and suggested it was fine for throwaway weekend projects.
Is vibe coding the same as using GitHub Copilot or Cursor?
No. Those are tools. Vibe coding is a way of using them: accepting their output without reviewing it. You can use the same tools and review every line, which is ordinary AI-assisted programming.
Can you vibe code a production app?
You can build one that runs, but you can’t responsibly maintain it without someone understanding the code. Secrets, cost, data handling and debugging all depend on knowing what the code does. Treat a vibe-coded app as a prototype until it has been reviewed and tested.
Was vibe coding the word of the year?
Yes. Collins Dictionary named “vibe coding” its Word of the Year for 2025, announced in November 2025.
Sources
- Andrej Karpathy, the original “vibe coding” post, February 2, 2025 (full text quoted in Willison’s post below)
- Simon Willison, Not all AI-assisted programming is vibe coding (but vibe coding rocks), March 19, 2025
- Collins Dictionary, Collins Word of the Year 2025, November 6, 2025
- METR, Measuring the Impact of Early-2025 AI on Experienced Open-Source Developer Productivity, July 2025