# Vibe Coding vs Agentic Engineering: Andrej Karpathy's Big Idea for AI Coding Most developers heard the phrase **vibe coding** and immediately understood the appeal. You describe what you want, the AI writes a chunk of code, you keep prompting, and suddenly you have something working that would have taken much longer by hand. But Andrej Karpathy's newer framing is more important for professional developers: **agentic engineering**. In a recent talk, Karpathy explained why AI coding is not just about writing code faster. The bigger shift is that LLMs are becoming a new computing layer. They can process messy information, act through tools, create software, rewrite data, and automate workflows that were not really possible with traditional code alone. That is exciting. It is also a little dangerous if we treat it like magic. Here are the big ideas from the talk and what they mean for developers. ## The Big Picture: AI Coding Is Moving From Output to Orchestration The main idea is this: **Vibe coding raises the floor. Agentic engineering raises the ceiling.** Vibe coding lets almost anyone create small apps, scripts, prototypes, and experiments. That is a big deal. The barrier to building software is lower than it has ever been. But agentic engineering is what happens when you still care about the things professional software has always required: - Security - Reliability - Architecture - Maintainability - Taste - Correctness - Deployment - Real user constraints In other words, vibe coding is about getting something working. Agentic engineering is about using AI agents to build something you can actually trust. That distinction matters. ## 1. The AI Coding Shift Became Obvious When the Code Stopped Needing Constant Correction Karpathy said there was a noticeable point where AI coding tools moved from helpful autocomplete to something much more agentic. Earlier tools could generate useful chunks of code, but you still expected to correct them often. The workflow was basically: 1. Ask for code. 2. Inspect it. 3. Fix the weird parts. 4. Ask again. Then the quality crossed a threshold. The chunks started coming out mostly right. You could ask for more, trust more, and keep going. That is the moment vibe coding became real. The key insight here is not that AI suddenly became perfect. It did not. The insight is that the interaction changed. The developer could move from typing every implementation detail to steering the work. That is a different job. You still need to understand what is being built, but you are spending more time directing, reviewing, and shaping the result than manually filling in every line. ## 2. Software 3.0 Means Prompting Becomes a Programming Interface Karpathy has used the terms **Software 1.0**, **Software 2.0**, and **Software 3.0** to explain the progression: - **Software 1.0:** Humans write explicit code. - **Software 2.0:** Humans train neural networks with data and objectives. - **Software 3.0:** Humans program LLMs through prompts, context, tools, and examples. That last one is the important shift. In Software 3.0, the context window becomes a kind of programming surface. The model is not just answering questions. It is interpreting instructions, looking at files, using tools, debugging errors, and changing its behavior based on the environment. Karpathy gave the example of installing software. Traditionally, you might write a giant shell script that tries to handle every OS, every dependency issue, every edge case, and every user environment. In an agentic world, the installer may instead be a set of instructions you give to an AI agent. The agent can inspect the machine, make decisions, run commands, notice failures, and adjust. That is not just a faster shell script. That is a different interface. ## 3. Some Apps Should Not Exist in Their Old Form Anymore One of the best examples from the talk was Karpathy's menu app idea. The original idea was straightforward: - Take a picture of a restaurant menu. - OCR the menu items. - Generate images of what each dish might look like. - Re-render the menu with pictures. That sounds like a normal AI app: upload image, process data, call models, generate output, display a polished interface. But then he saw the Software 3.0 version: give the menu image to a multimodal model and ask it to overlay the food images directly onto the menu. No elaborate app layer. No custom flow. The model did the transformation directly. That is the part developers need to sit with. A lot of software we are building right now may be temporary scaffolding around capabilities that the model itself will soon handle directly. The question changes from, "How do I build an app around this?" to, "What does the model already know how to transform?" That does not mean apps go away. It means many apps become thinner, more contextual, and more focused on workflow, trust, permissions, memory, and integration. ## 4. Verifiability Explains Where AI Improves Fastest Karpathy made a useful point about why AI models feel so uneven. They are incredible in some areas and strangely bad in others. They can refactor a large codebase, find bugs, and solve difficult programming tasks. Then they can fail at a question that feels obvious to a human. His explanation centers on **verifiability**. AI systems improve fastest in domains where the output can be checked. Code is a great example. You can run tests. You can compile. You can lint. You can compare expected output with actual output. Math works similarly. There are clear answers. That makes these areas ideal for reinforcement learning because the model can get a reward signal. It can try, get graded, and improve. For developers and founders, this is a practical filter: **If your domain has reliable ways to verify the output, AI will probably move faster there than people expect.** That includes more than code. It could include compliance checks, data transformations, financial reconciliation, testing, migrations, infrastructure validation, or any workflow where correctness can be measured. The more verifiable the work, the more automatable it becomes. ## 5. Jagged Intelligence Means You Still Need to Stay in the Loop The hard part is that AI capability is jagged. It does not improve evenly like a human slowly learning a field. It spikes in places where the training data, reinforcement learning, tooling, and evaluation all line up. Then it drops off in areas that seem nearby but were not represented as well. That is why an AI tool can be brilliant one minute and bizarre the next. This matters because developers can get lulled into trusting the system after several impressive outputs in a row. Then the agent makes a decision that looks plausible but is architecturally wrong. Karpathy gave an example from one of his apps where an agent tried to match a Stripe account and a Google account by email address. That sounds reasonable until you remember that people often use different email addresses for payment and login. The bug is not a syntax issue. It is a product and identity-modeling issue. That is exactly where the human still matters. ## 6. Vibe Coding Raises the Floor, But Agentic Engineering Preserves the Quality Bar This is the cleanest distinction in the whole talk. **Vibe coding** is about accessibility. More people can build software now. That is good. But **agentic engineering** is about maintaining professional standards while moving faster. You are still responsible for the software. If an agent introduces a security vulnerability, that is not acceptable just because the code was generated quickly. If it creates brittle abstractions, leaks data, mishandles auth, or ships an unreliable workflow, the responsibility still lands on the engineer and the organization. So the better question is not, "Can AI write this code?" The better question is: **Can I coordinate AI agents in a way that increases speed without lowering the quality bar?** That is where the real leverage is. ## 7. The AI-Native Developer Invests in the Setup Karpathy compared this to the way developers have always invested in their tools. Some developers are casual with their editor, terminal, dotfiles, snippets, and workflows. Others carefully build an environment that makes them much faster. AI coding is the same way. The AI-native developer is not just typing random prompts into a chat box. They are building a setup around the work: - Better project context - Better docs for agents - Clear specs - Test suites - Linters and type checks - Repeatable validation commands - Smaller tasks with clear boundaries - Multiple agents working in parallel when appropriate That is the difference between playing with an AI tool and engineering with it. If your repo is confusing to a human, it will probably be confusing to an agent. If your tests are weak, the agent has less feedback. If your docs are stale, the agent will confidently follow stale instructions. Agentic engineering pushes teams to make their systems more legible. ## 8. Human Taste, Judgment, and Understanding Become More Valuable One of my favorite lines from the talk was this: > You can outsource your thinking, but you can't outsource your understanding. That is the part developers should not skip. AI can write code. It can summarize. It can generate options. It can explore implementation paths. It can even use tools and take action. But someone still has to understand what is worth building, what tradeoffs matter, what the system should optimize for, and when a result is technically correct but strategically wrong. The details may shift. You may not need to remember every API parameter or every framework method. The agent can often fill those in. But the fundamentals matter more: - How data should be modeled - What the security boundaries are - What good architecture looks like - Where complexity is hiding - What users actually need - When the code is bloated or brittle - Whether the output makes sense That is not busywork. That is the job. ## 9. The Next Wave Is Agent-Native Infrastructure Karpathy also pointed out that most of the software world is still built for humans. Docs tell humans which buttons to click. Dashboards assume a human is navigating them. Deployment flows require people to jump between settings pages, copy values, configure DNS, and stitch services together manually. That starts to feel ridiculous when your agent can understand goals, use tools, and work through a checklist. The next wave is infrastructure designed for agents from the start: - Docs written with copy-pasteable agent instructions - APIs and CLIs that expose clean actions - Permission systems for delegated work - Audit logs for agent activity - Machine-readable configuration - Deployment flows agents can complete without babysitting This is one of the most practical opportunities right now. If your product can become easier for agents to use, it becomes easier for humans to automate. ## What Developers Should Do With This Here is the practical takeaway. Do not dismiss vibe coding. It is useful, and it is already changing who can build software. But do not stop there. If you are a professional developer, start learning agentic engineering: 1. **Write clearer specs.** Agents perform better when the destination is precise. 2. **Invest in tests.** Verifiability is leverage. 3. **Keep humans in charge of architecture.** Do not let the agent accidentally define your system boundaries. 4. **Make your repo agent-legible.** Good docs, commands, and conventions now help both humans and AI. 5. **Review for product logic, not just syntax.** The scary bugs are often reasonable-looking decisions. 6. **Use AI for exploration.** Let agents generate options, prototypes, migrations, and tests. 7. **Treat AI output as delegated work.** Faster does not mean unsupervised. The developers who win here will not be the ones who blindly accept every AI-generated diff. They will be the ones who learn how to direct the agents, verify the work, and keep the quality bar intact. ## Final Thoughts The phrase vibe coding was fun because it captured the feeling of building with AI when everything suddenly got easier. But agentic engineering is the phrase developers should pay attention to now. It points to the actual discipline: coordinating powerful, uneven, tool-using AI systems to build real software faster without shipping garbage. That is going to require better specs, better tests, better infrastructure, and better judgment. And honestly, that is a much more interesting future than just "AI writes code now."