Andrej Karpathy's Vibe Coding: The Rise and Fall

Andrej Karpathy dropped a tweet in February 2025 that renamed how a generation of developers talked about their work. "Vibe coding," he called it — fully giving in to the vibes, embracing exponentials, forgetting the code even exists. Within a year the phrase was everywhere, then it curdled into a buzzword, and by February 2026 Karpathy himself had quietly moved on. This guide traces the whole arc: what vibe coding actually meant, where it breaks, and what serious builders do instead.

What is Vibe Coding?

Vibe coding is software development where you lean on a large language model to generate code and trust its output rather than reading every line. Karpathy's framing was deliberately loose: describe what you want, accept the diff, run it, and if it works, keep going.

The core philosophy is about embracing exponential capability. Models improve fast, so why fight them with perfectionism? You prompt, you iterate, you ship.

This is a genuine break from structured, methodical coding, where every function is reasoned about and every architectural decision is deliberate. Vibe coding says: let the model hold the details, you hold the intent.

The mindset shift is real. You stop being the author and start being the director. That works beautifully — right up until it doesn't.

The Origins: Karpathy's Vision

The original post landed in early 2025 and spread within days. Wikipedia now credits Karpathy with coining the term.

What he actually meant was narrower than how it was received. His examples were throwaway projects — weekend apps, scripts, things where a bug just meant asking the model to fix it. The point was fun, not recklessness.

The misinterpretation came fast. "Vibe coding" got read as license to ship production software without understanding it. That is not what the phrase was built to carry.

Context matters. In early 2025, AI coding was good enough to feel magical and immature enough to fail silently. Vibes filled the gap between capability and reliability.

How Vibe Coding Actually Works in Practice

In practice, vibe coding is a rhythm: prompt, read the result loosely, run it, correct with another prompt. You stay in flow, and the LLM absorbs the tedium.

The skill is knowing when to override the vibe. If the output touches money, auth, or user data, you stop vibing and start reading. If it's UI scaffolding or a data transform, you let it ride.

Tools like Cursor and Claude made this possible, but the real enabler was architectural: choosing a stack and conventions the model already understands well. A model vibes better inside familiar terrain.

Vibe Coding Meets Production Reality

Vibes carry you through scaffolding. They collapse at the plumbing.

We learned this building BoiledPlate, where the stack was the easy part and the wiring ate the weeks. As we argued in how to ship SaaS fast, the framework picks itself — Stripe verification, row-level security, and idempotency are where launches actually stall.

You cannot vibe your way to a signature-verified webhook. Cryptographic correctness is binary. Full vibe coding fails at scale because the failures are silent: a user sees someone else's data, a subscription state drifts, a webhook fires twice.

What helps is structure. Building SaaS with agents requires contracts — an AGENTS.md file that documents one way to do data access and secrets, so the agent stays consistent instead of inventing a fourth pattern.

The Karpathy Pivot: Why He Moved On (February 2026)

By February 2026, Karpathy had publicly declared vibe coding outdated. His reasoning: LLMs got smart enough that "vibes" was no longer the right word for what good AI-assisted development looked like.

The landscape had matured. Models could follow explicit conventions, apply structured edits, and reason about architecture. The loose, forget-the-code-exists ethos felt incomplete against that.

His pivot signals something bigger: AI development grew up. The frontier moved from "trust the model" to "constrain the model well." The industry got stuck arguing about the word "vibe" while the actual evolution was happening in tooling and contracts.

Five Different Approaches to Vibe Coding

Pure vibes. Full trust, minimal oversight. Great for scripts and prototypes. Fails predictably for anything with real users.

Vibes with guardrails. Prompting combined with deterministic patches and schema validation, so the model's output gets checked before it lands.

Vibe coding for architecture. Use agents to design systems and explore options, then let humans wire the sensitive plumbing by hand.

Agent-native development. Build around an AGENTS.md contract so agents produce consistent output across months, not just across a single session.

Post-vibe coding. Structured prompting, explicit contracts, deterministic outputs. This is the direction Karpathy's pivot points toward.

Vibe Coding vs. Deterministic Coding

The problem with vibes alone is drift. An agent given three ways to fetch data will cheerfully add a fourth, because it has no reason to prefer yours.

Drift costs rework. Every time LLM output diverges from your conventions, someone has to notice, refactor, and re-explain — often the agent itself, badly.

Deterministic patches and semantic contracts prevent this decay. Instead of hoping the model matches your style, you encode the style as rules it must follow.

The concrete cases make it obvious: webhook idempotency, RLS policies, and multi-language i18n are all places where "close enough" is a bug. There are five places a new locale string has to land before the build stops complaining, and vibes will find four of them.

The Business Case: Vibe Coding in Startup Context

The speed gains from vibes are real and measurable — for the first mile. Scaffolding a landing page, a dashboard shell, a data model happens in minutes now.

Then the curve inverts. The weeks you saved on scaffolding get spent debugging the plumbing vibes couldn't handle. Founders who track this honestly land on the same rule: vibes for the MVP, structure for scale.

Karpathy's 2025 enthusiasm faded by 2026 partly through survivorship filtering. The demos that went viral were the ones that worked. The vibe-coded projects that quietly died in production billing bugs didn't trend.

Is Vibe Coding Dead?

The buzzword trap killed the term more than the technique. Once every tool marketed itself as "vibe coding," the phrase meant nothing.

What survived is the useful core: describe intent, let the model do the mechanical work, iterate fast.

What changed is the emphasis. LLMs are smarter, so the need for "vibes" shifted to "conventions." The real skill now is judgment — knowing when to trust the agent and when to enforce determinism.

The Anti-Hype Take: What Developers Actually Need

Here's the uncomfortable read: vibe coding solved the wrong problem. It framed the challenge as attitude — loosen up, trust the model — when the challenge was actually tooling.

The real innovation was never vibes. It was agent-readable contracts: AGENTS.md, structured prompts, deterministic provisioning. Every starter that ships the stack misses the point; the stack was never the hard part.

Starter kits with strong conventions beat pure vibes because they give the agent a floor. Building SaaS the way Karpathy now implies means structure plus AI, not vibes plus hope.

Technical Specifics: Where Vibes Fail

Some things simply do not bend to attitude:

• Webhook signature verification. You cannot vibe cryptographic correctness. See our writeup on treating the GitHub invite as the product, where some failures must throw and some must never.
• Row-level security. RLS is explicit, not emergent. A missing policy is a data breach, not a rough edge.
• Idempotent transactions. The two-generals problem doesn't care how confident your prompt sounded.
• Consent flows. German withdrawal law has specific requirements you encode into the pay button, or you don't sell legally.
• Billing state. Stripe webhooks are the source of truth, not the optimistic client-side success page.

Tools and Patterns for Post-Vibe Coding

This is exactly what BoiledPlate encodes: the lessons of vibe coding turned into structure. Instead of vibing through setup, an agent-driven interview provisions Stripe products and webhooks, a Supabase database with RLS, and Google sign-in in one session — deterministically.

The AGENTS.md contract is the evolution of vibes into something a machine can read and honor. And semantic, agent-readable release notes let agents apply updates consistently instead of guessing.

Lessons for the Next Wave of AI Coding

Vibe coding was a necessary phase, not the destination. It taught developers that intent-first workflows are faster — and that unstructured trust doesn't survive production.

Karpathy's pivot tells us where things head: verification over trust, contracts over vibes. The skills that will matter are prompt engineering, contract design, and knowing what to check.

The best AI-native code, it turns out, looks less like vibes and more like highly structured conventions a model can follow without drifting.

FAQ: Common Misconceptions About Vibe Coding

Does vibe coding mean no testing? No. The durable version is vibes plus verification — generate loosely, validate strictly.

Is Karpathy saying not to use LLMs? The opposite. Use them heavily, but with determinism and explicit constraints.

Can I ship production SaaS on vibes alone? Not sustainably. The plumbing — billing, security, compliance — demands structure.

What's the successor to vibe coding? Agent-native development built on contracts. Start from a boilerplate designed for agents rather than vibing the wiring yourself.