Beyond Vibe Coding: The Rise of Agentic Engineering

In February 2026, Andrej Karpathy posted a tweet that sent shockwaves through the AI coding community: Vibe Coding is dead. The future belongs to Agentic Engineering.

The irony was not lost on anyone. Vibe Coding was a term Karpathy himself coined in 2025. A year earlier he was telling developers to "embrace the vibe, ignore the code details." A year later, he was presiding over its funeral.

This isn't a reversal. It's intellectual honesty. When someone recognizes their own mistake faster than anyone else and says so without hedging—that alone deserves attention.

Vibe Coding Was a Democratization Experiment

Let's establish what Vibe Coding actually was.

The workflow was dead simple: have a fuzzy idea → describe it to AI in natural language → AI generates code → if it runs, ship it → if it breaks, throw it back to AI. No architecture planning. No test-driven development. No code review. The core belief: make software development feel like chatting.

This paradigm swept through the developer community in 2025. Tools like Cursor, Windsurf, Lovable, and Bolt gave millions of non-coders their first taste of "creating software." For small projects, prototypes, and internal tools, Vibe Coding delivered astonishing efficiency.

Then the cracks started showing.

The Cracks Began With "It Runs"

In June 2026, security research firm Wiz uncovered something chilling.

Moltbook—a product billed as "the social network for AI agents"—had a misconfigured Supabase database that left its production environment wide open to anyone: 1.5 million API authentication tokens, 35,000 email addresses, and countless private messages between AI agents, all exposed on the public internet. Anyone could impersonate any AI agent on the platform and tamper with all public content.

The founder was refreshingly honest: the product was vibe-coded. He hadn't written a single line of code himself. AI generated everything.

This was not an isolated incident. RedAccess, an Israeli security firm, discovered approximately 380,000 publicly accessible assets, roughly 5,000 of which contained sensitive corporate information—medical records, financial data, internal documents. Most of these applications were built on AI/low-code platforms like Lovable, Replit, and Netlify. RedAccess's CEO put it bluntly: "The default privacy setting on these applications is public access."

Lovable itself got hit. Researcher weezerOSINT found that with a few API calls from a free account, they could access other users' source code, database credentials, and AI chat histories—a textbook BOLA (Broken Object-Level Authorization) vulnerability. The incident devolved into a blame-shifting spiral between the platform, its users, and the vulnerability disclosure process.

The barrier to building a working app has been demolished by AI. The barrier to knowing you're running naked in public? Hasn't moved an inch.

The Super-User Divide: AI Didn't Close the Gap, It Widened It

Cursor's Spring 2026 Developer Habits Report revealed an even harsher trend:

• The top 1% of users produce 46 times more code than the median active user
• They merge 15 times more commits than the median contributor
• Token consumption, AI spending, and code output are all hyper-concentrated among a tiny elite

AI coding didn't level the playing field. It turned the gap between elite developers and everyone else into the Mariana Trench.

Why? Because knowing how to make AI write code and knowing how to make AI do engineering are two entirely different skills. The first requires describing what you want. The second requires understanding architecture, testing, security, and deployment. Vibe Coding only solved the first.

What Agentic Engineering Actually Means

At the Sequoia AI Ascent summit in April 2026, Karpathy laid out his new paradigm in detail. He opened with a devastating analogy:

The most advanced large language model can restructure a 100,000-line codebase in one shot—and will also suggest you walk to a car wash 50 meters away.

You want to wash your car. The car cannot walk. So walking to the car wash is a nonsensical suggestion. A model capable of restructuring 100,000 lines of code collapses on a piece of common sense a three-year-old would get right.

Karpathy calls this Jagged Intelligence—AI capability does not advance uniformly. It's spiky. Judging AI with a binary "it works / it doesn't" is the most dangerous way to think about it today.

Agentic Engineering aims to address exactly this unreliability that comes from jagged capability. The core distinction:

Dimension	Vibe Coding	Agentic Engineering
Planning	None—iterate on vibes	Plan first, execute after
Code Quality	If it runs, ship it	Maintainable, testable, secure
Testing	Almost none	TDD red-green-refactor cycle
Human Role	Describe requirements, accept output	Define constraints, review decisions
AI Role	Code generator	Full-lifecycle engineering agent

A typical Agentic Engineering workflow looks like this:

Requirements → Agent converts natural language into structured technical specs Architecture → Agent analyzes requirements, proposes architecture; human reviews and adjusts Step-by-step implementation → Agent decomposes into independent subtasks, implements each, handles dependencies Testing → Agent auto-generates test cases, runs them, fixes failures Deployment → Agent generates deploy configs, deploys, monitors

This isn't traditional software engineering transplanted into the AI era—it's AI agents becoming the planners and executors, with humans shifting from "the person who writes code" to "the person who defines what 'correct' means."

The Toolchain Is Already Pivoting

Agentic Engineering isn't theoretical. The tool ecosystem is already moving in this direction.

Claude Code is the most aggressive practitioner. Terminal-native by design, operating directly on the file system and Git repository. Opus 4.5 scored 80.9% on SWE-bench Verified. It demonstrates a key direction: the terminal is becoming the primary interface for autonomous coding.

Codex validates another pattern: terminal-native plus editor integration, with configurable approval modes and sandboxed execution. Teams can dial autonomy up or down to find their comfort zone.

TDD AI Agents are emerging as the most reliable pattern for autonomous coding. Instead of generating code and hoping it works, they follow the standard red-green-refactor cycle: write tests first, generate code, make tests pass, refactor. Platforms like KiloCode have productized this, supporting 500+ models with BYOK pricing.

Karpathy also highlighted three "new horizons" worth watching:

• .md instead of .sh: OpenClaw installs not with a bash script, but with a Markdown instruction block—the agent examines your environment, debugs, and configures autonomously
• LLM Wiki: Not zero-shot RAG every time. The model continuously maintains a knowledge base in a Markdown folder—new documents auto-update entries, add links, flag contradictions
• Software 3.0: His MenuGen app (OCR + image generation) got obliterated by a single Gemini prompt—"not making old software faster, but compressing an entire engineering project into one model output"

What This Means for Developers

Vibe Coding isn't going away. Personal tools, prototypes, one-off scripts—these don't need engineering rigor, and Vibe Coding remains the most efficient way to build them.

But if you're building a product for real users, Vibe Coding is no longer enough. Not because writing code got harder—quite the opposite. Writing code got so easy that the truly expensive parts are no longer implementation, but design, security, testing, and maintenance.

Agentic Engineering isn't a regression to heavyweight traditional processes. It's about finding the human developer's irreplaceable position after AI takes over the coding work: defining what "right" looks like, rather than scrutinizing every line.

Karpathy closed his fireside chat with something like this: You can outsource the process of thinking. You cannot outsource the responsibility of understanding.

That sentence, more or less, is the entire thesis of Agentic Engineering.