What Is Vibe Coding and How Natural-Language Development Replaces Manual Code Editing
Table of Contents
ELI5
Vibe coding is building software by describing what you want in plain language and letting an LLM write the code — without ever reading it yourself. Coined by Andrej Karpathy in February 2025.
The phrase sounds like a joke from a developer satire account. A researcher who once led Tesla’s AI work tells the public he has stopped looking at the code he produces — he just describes the feature, accepts whatever the model writes, and moves on. The instinct is to call this lazy or careless. The interesting move is to take Karpathy at his word and ask what actually changed in the workflow that made the code itself optional.
The shift from artifact to intent
The word “coding” has always meant editing a specific artifact: a file of source code that a compiler or interpreter consumes. Vibe coding is the deliberate inversion of that workflow. The artifact is still produced, but it is no longer the thing the human attends to.
What is vibe coding?
Vibe coding is, in Karpathy’s original framing, the practice of building software with an LLM by describing intent in natural language and accepting the generated code without reviewing it. His tweet on February 2, 2025 (Karpathy on X) put it more bluntly: “fully give in to the vibes, embrace exponentials, and forget that the code even exists.”
That definition is doing more work than it looks. Simon Willison narrowed it almost immediately in a March 2025 essay arguing that “not all AI-assisted programming is vibe coding” — the discipline of accepting code without reading it is the defining trait, not the use of an AI assistant (Simon Willison’s blog). Most “vibe coding” in 2026 has drifted from this strict definition; the industry now uses the term for any natural-language coding workflow, whether the developer reviews the output or not.
Not a lifestyle. A workflow choice with a specific tradeoff.
The tradeoff is throughput against scrutiny. By treating generated source code as a transient byproduct — like the assembly an optimizing compiler emits from your C — vibe coding moves the unit of human attention up one level of abstraction. The developer’s job becomes specifying behavior and judging outcomes; reading symbols is delegated.
Karpathy himself has since softened the framing. In a 2026 retrospective he proposed “agentic engineering” as the preferred term for professional contexts (Karpathy on X), reserving “vibe coding” for prototyping and exploratory work. The terminology is unsettled. The workflow is not.
The loop from words to running software
A vibe coding session does not feel like one big “prompt → code” act. It feels like a conversation in which the program emerges, run after run, until the behavior matches what the developer pictured. The loop is small, fast, and recursive.
How does vibe coding work end to end from prompt to running app?
The canonical workflow loop documented by Google Cloud is six stages: Intent → Plan → Generate → Run → Review → Iterate (Google Cloud). Each stage is short. The whole loop can complete in seconds for a UI tweak, or in minutes for a feature that touches database schema, backend endpoints, and frontend state.
In practice it unfolds like this:
Intent. The developer types a goal in natural language: “Add a billing page that lists subscriptions and lets a user cancel.” There is no specification, no ticket, no design doc.
Plan. The agent reads the existing codebase, identifies which files it must touch, and emits a plan — what it will create, modify, install. Stronger agents present the plan for approval; weaker ones execute silently.
Generate. The model writes or edits source files via tool calls, not by streaming code into a chat window. The agent edits the same file system the developer’s editor reads.
Run. The agent executes the code — starts a dev server, runs migrations, opens a browser, takes a screenshot, runs tests. This is where the loop becomes interesting; the model now has feedback that is not text.
Review. The developer looks at the running app, not the diff. If the billing page renders correctly and cancel works, that is the acceptance criterion.
Iterate. A new sentence: “Make the cancel button red.” Back to step 2.
Notice what is absent from this loop: any guarantee that the developer ever opens the generated files. The artifact still exists on disk; it just is not the channel through which the developer evaluates progress.
The mechanism that makes step 4 possible is worth pausing on. An LLM producing text in isolation cannot run code. What it can do is emit structured tool calls — JSON objects naming a function and its arguments — that an agent runtime translates into real actions: read file, write file, run shell command, take screenshot. The model’s output is not the program; the model’s output is a sequence of operations on a program.
The architecture beneath the vibe
The end-user experience hides several distinct components doing distinct work. A 2025 academic preprint proposed one way to decompose them.
What are the core components of a vibe coding workflow?
The reference architecture published by Vinay Bamil (arXiv 2510.17842) names four functional pieces:
| Component | Role | What it consumes | What it emits |
|---|---|---|---|
| Intent Parser | Translates the developer’s natural-language goal into a structured task | Free-text prompt + conversation history | Typed plan / action list |
| Semantic Embedding Engine | Finds the relevant slice of the existing codebase | Repository contents indexed as vectors | Top-K relevant files/snippets |
| Agentic Code Generator | Writes the diff, calls the tools, runs the code | Plan + retrieved context + tool API | File edits + tool invocations |
| Interactive Feedback Loop | Captures runtime signals and routes them back | Errors, screenshots, test output, user replies | Next iteration’s context |
This is one proposed decomposition, not an industry-standard taxonomy. Production tools mix and rename these pieces — Cursor’s Agent, Claude Code, Lovable, Replit Agent, Bolt, v0, and Windsurf each draw the boundaries differently — but the functional roles map onto every working system.
The unsung component is the one that connects the model to the outside world. Most vibe coding agents now speak the Model Context Protocol, an open standard introduced by Anthropic in November 2024 (Anthropic) for exposing tools and data sources to LLMs through a uniform interface. By December 2025, the protocol’s reference SDKs were receiving 97M+ monthly downloads across 10,000+ active servers, and Anthropic donated MCP to the Linux Foundation’s Agentic AI Foundation (Pento blog). Treat those numbers as directional — they come from a single Anthropic-reported snapshot — but tool access for code agents is becoming infrastructure.
The semantic embedding step is what lets a workflow scale beyond trivial scripts. Without it, the agent would have to either re-read the entire repository on every turn (token-prohibitive past small codebases) or guess which files matter (error-prone). With it, the relevant files are retrieved on demand and inserted into the Context Window just in time.
What the workflow predicts
A workflow that moves the unit of attention from the artifact to the behavior makes specific predictions about what will get easier and what will get worse.
- If the task is bounded and visually verifiable, expect throughput gains. Landing pages, internal dashboards, prototypes, and one-off scripts — anything where “looks right and works” is a sufficient test — collapse from hours into minutes.
- If the task is unbounded or invisibly stateful, expect failure modes the developer cannot see. Background jobs, security boundaries, billing logic, race conditions — anything whose correctness is not observable from a screenshot — will produce code that runs and is wrong.
- If the generated code accumulates unread, expect debt that compounds. Each new iteration is conditioned on the existing files. AI Code Migration costs rise sharply when nobody on the team has read the system.
Rule of thumb: vibe coding works in proportion to how cheaply you can test the output by running it.
When it breaks: The defining limitation is invisibility. A Hallucination in a vibe-coded system is not a wrong sentence — it is a function that imports a library that does not exist, or a security check that silently accepts every request. Because the developer did not read the code, the failure surfaces only when the runtime hits the bad path. Strict Karpathy-style vibe coding is therefore appropriate for throwaway artifacts and risky for anything load-bearing; this is why Karpathy himself now reserves the term for prototypes.
The Data Says
Vibe coding is not “AI writes the code” — it is the deliberate decision to stop treating source code as the unit of human attention. The Karpathy → Willison → industry drift shows the discipline being negotiated in public; the reference architecture and the spread of MCP show the plumbing converging. What is still unsettled is which class of software this workflow can safely produce, and the boundary is exactly where the runtime signal stops being a reliable proxy for correctness.
AI-assisted content, human-reviewed. Images AI-generated. Editorial Standards · Our Editors