What is vibe coding?
Vibe coding is what happens when you stop reading the code. You tell a model what you want, it writes the program, you run the program, and you judge it by the result. If it breaks, you paste the error back and say “fix it.” If it’s close, you say “more like this.” The code is still there. You are just not the one who reads it.
Andrej Karpathy named it in February 2025:
“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.”
Andrej Karpathy, February 2025
The phrase moved fast. Merriam-Webster listed it as trending slang within weeks, and Collins English Dictionary made it their Word of the Year for 2025. By then it described a large share of how software actually gets started.
The useful line is one the developer Simon Willison drew early: if you read every change and understand it, that is AI-assisted programming, and it is an old idea. Vibe coding is specifically the version where you don’t. Neither is wrong. What changes is where responsibility sits, and how you get it back when you need it.
Vibe coding vs AI-assisted vs agentic coding
Three phrases get used for the same afternoon of work. They describe different amounts of control.
| AI-assisted coding | Vibe coding | Agentic coding | |
|---|---|---|---|
| Who writes it | You, with the model completing lines and answering questions | The model, from your description | One or more agents, from a task |
| Who reads it | You, every line | Nobody, until something breaks | You, at the boundaries you choose |
| Who runs it | You | You, by hand, watching the result | The agent — it runs tests and commands itself |
| Good for | Code you will maintain for years | Prototypes, tools, throwaway UI | Multi-step work across a real repo |
| Failure mode | Slow | Code nobody understands | An agent doing something you didn’t mean |
In practice a working session drifts between all three. You vibe a prototype, hand the agent a test suite, then read the diff around the payment form. The term stuck because it names the moment you decide to stop reading, and that decision is the whole game.
How the loop works
Every vibe coding tool runs the same four-beat loop.
- Describe. A sentence, a screenshot, a failing test, a link to something you like. The less precise the prompt, the more the model’s defaults decide.
- Generate. The model edits files. Terminal agents also run commands: install packages, start servers, run the tests.
- Run. You look at the app, not the diff. Does the button do the thing? Does the number match?
- React. Paste the error. Say what’s off. Ask for the next thing. Repeat until it works or you’re bored.
Where it shines: weekend projects, internal tools, one-off scripts, dashboards, the UI you will look at once and throw away, data migrations you can re-run. Where it strains: authentication, money, personal data, anything that deletes, and anything another person will have to maintain.
The tools people vibe code with
Most tools fall into three groups. The models behind them overlap — Claude, GPT, Gemini, and open-weight models through a local runtime. The difference is where the loop runs.
Terminal agents
- Claude Code
- Codex
- Gemini CLI
Live in your repo, edit files directly, run your tests and shell commands, and reach tools through MCP. The most capable group and the least supervised.
Agentic editors
- Cursor
- Windsurf
- GitHub Copilot
- Zed
The same loop inside an editor. You see the diff whether you read it or not, which is the point.
App builders
- Replit
- Lovable
- Bolt
- v0
Hosted, whole app from a prompt, deploy button attached. The fastest zero to demo and the hardest to get the code out of later.
Pick by where you want the code to live. If the answer is “on my machine, in git, with my own keys,” you want a terminal agent and something to keep it in check.
Where it breaks
Vibe coding fails in five predictable ways. None of them are the model being dumb. They are the loop being unsupervised.
Vibe debt
Code nobody read is code nobody can change. It compounds faster than ordinary tech debt because there is no memory of why anything is the way it is.
Security by default
Models write what is common, not what is safe: secrets in source, missing authorization checks, string-built queries. The prototype ships, then it is the product.
Irreversible actions
Agents run commands. An agent that can drop a table or force-push will eventually do it. In 2025 one widely reported case had an agent delete a production database during a declared code freeze, then explain itself afterwards.
Cost drift
An agent looping on a failing test can spend a surprising amount of money in an afternoon, and most tools show you the bill later, not during.
One lane
One chat, one agent, one thing at a time, and you are the one waiting. Long sessions also decay: the agent forgets what it changed an hour ago.
How to vibe code without the mess
You can keep the speed and lose most of the risk with a handful of habits. They are the habits a good team already has. The difference is that an agent needs them enforced, not suggested.
- Gate anything irreversible. Deletes, pushes, deploys, payments, emails: a person says yes first. Every time.
- One agent, one worktree. Give each run its own git worktree on its own branch. Nothing lands on main until you have looked, and two agents cannot trample each other.
- Make the test the spec. Write the failing test yourself, or have the agent write it and read that. Then let it chase green. A test is a prompt that does not drift.
- Read at the boundaries. Skip the internals if you like, but read every line that touches auth, storage, money or deletion. That is a small fraction of the diff and most of the risk.
- Keep keys and code on your machine. Use your own API keys, run local models where you can, and do not route your repo through someone else’s cloud to get a coding agent.
- Meter every run. Know what a task cost before you start the next one.
- Work in slices you could throw away. Small prompts, frequent commits. If a slice goes wrong, discard the worktree and start again. That is cheaper than debugging vibes.
Vibe coding on a Mac, with ARC
ARC is an AI agent orchestration platform for macOS built around exactly that list. It runs the terminal agents you already use — Claude Code, Codex, Gemini CLI — in parallel, each in its own git worktree, with a gate in front of anything that moves.
The gate
Nothing moves without your say. A breaker on every line.
Worktrees
Every agent gets its own branch and its own worktree. Main stays yours.
Metered
Every run costed to the cent and written down.
Local-first
Keys, code and prompts stay on your Mac. Developer ID signed and notarized, no cloud middleman.
ARC is in private beta. A founders license is one payment of $199, yours for good, with every update for as long as ARC exists. Beta invites go out in license order.