What Is Vibe Coding? The AI-Assisted Way to Build Software
Vibe coding is software development where you describe what you want in plain English and a large language model writes the code for you — hardware built for vibe coding, like the Codex Micro macropad, turns that back-and-forth into single button presses.
The phrase was coined by Andrej Karpathy in February 2025, and it moved fast enough that Collins English Dictionary named vibe coding its Word of the Year for 2025 just nine months later.
What Vibe Coding Actually Means
From typing lines to describing intent
Vibe coding is software development where you describe what you want in plain English and a large language model produces the code. Instead of writing every line yourself, you steer the process: prompt, review, re-prompt. Karpathy put it bluntly — he said the point was to “fully give in to the vibes… and forget that the code even exists.” That framing is what separates vibe coding from ordinary AI-assisted software development, where a human still authors most of the logic and the model just fills gaps.
The natural language prompt is the whole interface. You’re not memorizing syntax or hunting through documentation — you’re stating intent, and a large language model translates that intent into working code, then adjusts it when you push back.
Pure vs. responsible vibe coding
“Pure” vibe coding, in Karpathy’s original sense, means accepting the AI’s output without close review — you don’t read the diff, you just run it and see if it works. “Responsible” AI-assisted development keeps the same conversational workflow but adds a human checkpoint: you still review, test, and understand what shipped before it goes live.
That distinction matters more than it sounds. Prototyping a weekend project and shipping a production system that handles user data are not the same risk profile, even if both start with the same natural language prompt.
The two modes tend to differ along the same few lines:
- Pure vibe coding: prompt, accept, move on — no diff review.
- Responsible AI-assisted coding: prompt, read the diff, test, then accept.
- Pure suits throwaway prototypes and personal tools.
- Responsible is the baseline for anything with real users or real data.
Where the Term Came From
Andrej Karpathy, February 2025
The term was coined by Andrej Karpathy — a co-founder of OpenAI and former director of AI at Tesla — in a February 2025 post on X. It built directly on something he’d said back in 2023: that “the hottest new programming language is English.” Vibe coding was the natural extension of that idea once large language models got good enough to act on English instructions directly, rather than just autocomplete inside existing code.
Karpathy has spent much of his career at the intersection of research and applied engineering, which is part of why the phrase landed — it came from someone building the OpenAI models that made the workflow possible, not from a marketing team trying to name a trend after the fact.
There’s 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… I “Accept All” always, I don’t read the diffs anymore.
Andrej Karpathy
From tweet to word of the year
Merriam-Webster logged “vibe coding” as a term to watch in March 2025, just weeks after Karpathy’s post. Collins English Dictionary went further and named it Word of the Year on 6 November 2025 — a nine-month sprint from a single social post to lexicographic recognition, which is unusually fast even for tech vocabulary.
How Vibe Coding Works
The mechanics are a loop, not a one-shot request. You describe the feature, the model writes it, you check the result, and you describe what needs to change. Repeat until it’s done.
- Describe the feature in plain language — what it should do, not how.
- The model generates code based on that description.
- Run or test it to see whether the behavior matches what you asked for.
- Describe what to change if it doesn’t — a bug, a missing case, a style tweak.
- Repeat until the output is acceptable, then move to the next feature.
Modern coding agents extend that loop well past code generation. They can create new files, run terminal commands, install dependencies, and in some setups deploy the result — all still driven by the same natural language prompt cycle.
The prompt-generate-test-refine loop
This loop is what people mean when they say vibe coding “feels” different from traditional programming. You’re not tracing through a call stack to find a bug; you’re describing symptoms and letting the model propose a fix, then judging whether that fix actually solves the problem.
Some sessions stay purely conversational — text in, code out. Others bring in AI agents that hold state across many steps, remembering earlier decisions in the same session so you don’t have to repeat context every time you re-prompt.
Steering agents, not just autocomplete
This is where dedicated tooling starts to matter. Coding agents like OpenAI Codex turn a single prompt into multi-file changes and even open pull requests on their own, rather than suggesting one line at a time. A hardware controller such as a programmable macropad complements that shift — instead of reaching for the mouse to click accept, reject, or re-run, you trigger those actions with a dedicated key and stay in the flow of the conversation with the agent.
Vibe Coding vs. Traditional Coding
What changes, what stays
In traditional coding, you author and debug every line yourself, using your own understanding of the syntax and the logic to catch mistakes. In vibe coding, you specify intent and curate the model’s output — the writing shifts from you to the LLM, but the judgment about whether the result is correct still has to come from somewhere.
The trade-off is speed for direct control. You move faster because you’re not typing every character, but you also have less first-hand certainty about what a given block of generated code actually does until you read it.
| Aspect | Traditional coding | Vibe coding |
|---|---|---|
| Who writes the code | The developer, line by line | The LLM, from a natural language prompt |
| Primary skill | Syntax, debugging, algorithms | Describing intent, evaluating output |
| Speed | Slower for boilerplate | Faster for prototypes and routine features |
| Review burden | Continuous, built into writing | Concentrated after generation |
| Best use case | Production systems, complex logic | Prototypes, small tools, non-critical features |
The Tools Behind It
From autocomplete to full agents
Vibe coding tools split roughly into four categories, and the difference between them is how much of the loop they own.
Completion assistants suggest code as you type but leave the overall structure to you — GitHub Copilot is the best-known example of this category. AI-native IDEs like Cursor and Windsurf build the conversational loop into the editor itself, so prompting and reviewing happen in the same window as the code. App builders such as Replit, Lovable, and bolt.new go further still, generating and hosting entire applications from a prompt with little manual setup. Agentic tools like OpenAI Codex take on a whole task — reading a repository, making changes across multiple files, and proposing a finished pull request rather than a single suggestion.
In short, the four categories break down as:
- Completion assistants — inline suggestions inside an existing file.
- AI-native IDEs — prompt, review, and edit in one window.
- App builders — a full app scaffolded and hosted from a single prompt.
- Agentic tools — multi-file tasks and pull requests with minimal supervision.
| Category | Examples | What it owns |
|---|---|---|
| Completion assistants | GitHub Copilot | Line and function-level suggestions |
| AI-native IDEs | Cursor, Windsurf | In-editor prompt-generate-test loop |
| App builders | Replit, Lovable, bolt.new | Whole app scaffolding and hosting |
| Agentic tools | OpenAI Codex, Claude Code | Multi-file tasks, pull requests, deploys |
Software and hardware increasingly pair up here: an agentic tool handles the code, and a physical control surface handles the accept, reject, and run actions that used to mean reaching for a trackpad every few seconds.
Benefits and Risks
Why people love it
Amateurs can ship working software without formal training, and experienced developers use the same workflow to prototype far faster than they could by hand. The scale of adoption backs that up: in Y Combinator’s Winter 2025 batch, a quarter of startups reported that 95% of their codebase was AI-generated.
That speed shows up in a few consistent ways:
- Non-programmers can build working prototypes without learning a language first.
- Experienced developers skip boilerplate and get to the interesting logic faster.
- Iteration cycles shrink from hours of manual debugging to minutes of re-prompting.
- Small teams can cover more ground without hiring specialists for every stack.
Where it bites back
Critics point to accountability, maintainability, and security as the recurring failure modes. One audit found that 170 of 1,645 apps built with Lovable exposed user data through misconfigured access controls — a direct consequence of shipping generated code without a security review. Productivity gains aren’t guaranteed either: a randomized controlled trial by METR found that experienced developers were actually 19% slower on some tasks when using AI assistance, likely because reviewing and correcting generated code took longer than writing it from scratch would have.
The recurring risks worth tracking before you ship anything built this way:
- Security vulnerabilities from code that was never reviewed line by line.
- Technical debt that accumulates because no one fully understands the generated logic.
- Accountability gaps when something breaks and no one can explain why it was written that way.
- Overconfidence in output that looks correct but hasn’t been tested against edge cases.