The era of “vibe coding” was fun while it lasted, but the landscape of artificial intelligence moves at a blistering pace. Just a year ago, developers were celebrating the ability to “give in to the vibes,” letting Large Language Models (LLMs) handle the bulk of coding through intuition and prompting. It was a chaotic, fast, and often impressive way to prototype. But as we settle into 2026, the novelty has worn off, and the industry is demanding reliability over vibes. Enter Agentic Engineering.
This shift isn’t just a change in terminology; it represents a fundamental restructuring of how software is built. Andrej Karpathy, a central figure in modern AI development, has officially declared vibe coding “passé.” The new default workflow involves autonomous agents, rigorous oversight, and a complete reimagining of the human developer’s role. If you are writing code line-by-line today, you might already be doing it wrong.
From Vibe Coding to Agentic Engineering
To understand where we are going, we have to look at the brief but intense history of the last twelve months. In early 2025, Karpathy coined the term “vibe coding.” It described a workflow where developers used LLMs like Cursor Composer or Claude to generate code rapidly. You didn’t necessarily read every line; you checked if it worked, fixed errors through natural language prompts, and moved on. It was about speed and “embracing exponentials.”
However, as models like GPT-5 mini and Claude Opus 4.6 matured, the capability of AI grew from mere assistance to genuine autonomy. Vibe coding was excellent for throwaway projects or quick prototypes, but it lacked the discipline required for enterprise-grade software.
Karpathy now defines Agentic Engineering as the natural successor. In this model, you are not writing the code directly 99% of the time. Instead, you are orchestrating agents who do the heavy lifting. You act as the oversight committee, the architect, and the quality assurance lead. The “engineering” part of the name is crucial—it emphasizes that despite the automation, there is still an art, science, and deep expertise required to manage these systems effectively.
What is Agentic Engineering?
Agentic Engineering marks a transition from “human-in-the-loop” to “human-on-the-loop.” In a traditional setup, or even in vibe coding, the human drives the process. You type a prompt, the AI generates a snippet, you paste it, and you debug it.
In an agentic workflow, the dynamic is different. You define high-level goals, quality standards, and architectural constraints. The AI agents then plan the approach, reason through dependencies, write the code, and even attempt to run it. The agents possess a form of “adaptive thinking,” allowing them to handle complex tasks that require memory and multi-step execution.
The Core Differences
- Scope: Vibe coding focuses on rapid feature creation and experimentation. Agentic Engineering focuses on building autonomous workflows and robust decision-making systems.
- Interaction: In vibe coding, you collaborate and tweak outputs constantly. In Agentic Engineering, you supervise and set the rules of engagement.
- Structure: Vibe coding is free-form and intuitive. Agentic Engineering is structured, relying on defined tools, memory, and specific agent roles.
This shift allows for a massive leverage of productivity. The goal is to claim the efficiency of agents without compromising on software quality. It turns the developer into a manager of a digital workforce.
The Infrastructure Crisis: When Agents Break Testing
One of the most significant side effects of Agentic Engineering is the sheer volume of code being produced. When you have agents writing code faster than any human team ever could, traditional infrastructure begins to crack. The most immediate casualty is software testing.
For the last 50 years, testing has followed a predictable pattern: engineers write code, and they (or QA specialists) manually write tests to verify that code. These tests are static. They need to be maintained, updated, and reviewed. But when an agent generates a massive pull request in seconds, the human bottleneck shifts from coding to testing. You cannot manually write tests fast enough to keep up with an agentic workflow.
The Rise of Just-in-Time (JiT) Testing
To solve this, major tech players like Meta have introduced concepts like Just-in-Time (JiT) Testing. This is the infrastructure backbone that makes Agentic Engineering possible at scale.
JiTTests are fundamentally different from the static test suites of the past. Instead of a human maintaining a repository of regression tests, LLMs automatically generate tests on the fly the moment a code change is submitted. These are “bespoke” tests tailored specifically to the changes the agent just made.
This approach solves several critical problems:
- Speed: Tests are generated instantly, matching the pace of agentic coding.
- Relevance: The tests focus specifically on the logic that changed, rather than running a generic suite that might miss nuances.
- Maintenance: There is no test code to maintain. The tests are ephemeral; they serve their purpose to verify the change and ensure no regressions are introduced, without adding to the technical debt.
By using “Catching JiTTests,” the system can infer the intention of the code change and simulate possible faults. This reduces false positives—a plague in traditional automated testing—and allows the human engineer to focus only on real bugs. In this ecosystem, agents write the code, and other agents write the tests to check that code.
Is the Software Engineer Obsolete?
With agents handling the writing and other agents handling the testing, the existential question arises: Is the role of the software engineer dead?
Dario Amodei, CEO of Anthropic, recently suggested that traditional software engineering might be “obsolete” within a very short timeframe—perhaps as soon as 6 to 12 months. He envisions a world where the model does everything a software engineer does, end-to-end.
However, Karpathy’s definition of Agentic Engineering suggests a transformation rather than an extinction. The role is moving up the abstraction ladder. Just as compilers freed us from writing assembly code, and high-level languages freed us from memory management, agents are freeing us from syntax and boilerplate logic.
The new skill set involves:
- System Architecture: Understanding how different agents should interact.
- Oversight and Governance: Knowing how to evaluate the quality of agentic output.
- Constraint Definition: Setting the boundaries within which the agents operate to ensure safety and compliance.
The “engineering” in Agentic Engineering is about the rigorous application of these high-level skills. It is about designing the factory, not assembling the car.
Why This Matters Now
We are at a convergence point. In 2026, we are seeing improvements on the model layer (smarter LLMs) and the agent layer (better orchestration tools). This combination unlocks capabilities that were impossible during the vibe coding era of 2025.
The transition to Agentic Engineering is driven by necessity. As software becomes more complex, the cognitive load required to maintain it manually becomes unmanageable. We need leverage. By adopting an agentic approach, businesses can build more software, faster, and potentially with higher quality—provided the oversight mechanisms are in place.
The romantic image of the lone coder typing late into the night is fading. In its place is the Agentic Engineer, a conductor of a symphony of algorithms, guiding the creation of complex systems through intent and supervision. Vibe coding was a fun experiment; Agentic Engineering is the industrial revolution of software.
