Agentic engineering: why vibe coding grew up in 2026

In February 2026, Andrej Karpathy proposed a term that reframed how the industry talks about AI-assisted development: agentic engineering. The label replaced "vibe coding," the informal shorthand Karpathy himself coined in 2025 to describe the practice of prompting AI to write code without much human scrutiny. The shift in vocabulary reflects a shift in practice. Developers moved from casual experimentation to structured workflows where AI agents plan, write, test, and iterate on code under deliberate human oversight.

This article breaks down what agentic engineering actually means, why the industry needed a better term than vibe coding, and how development teams are adopting it in production environments today.

What is agentic engineering?

Agentic engineering is the discipline of building software by orchestrating AI coding agents under structured human supervision. The developer defines specifications, sets constraints, and reviews output while the agent handles code generation, testing, and iteration autonomously within those boundaries.

Karpathy's own definition is precise: "'Agentic' because the new default is that you are not writing the code directly 99% of the time, you are orchestrating agents who do and acting as oversight — 'engineering' to emphasize that there is an art and science and expertise to it."

This differs from traditional coding (where humans write every line) and from vibe coding (where humans prompt AI with little regard for the output quality).

Why vibe coding needed a replacement

Vibe coding served its purpose as a provocation. When Karpathy introduced the term in early 2025, the intent was to name a real phenomenon: developers prompting LLMs to generate code and shipping it without deep inspection. For prototyping, throwaway scripts, and quick experiments, that workflow made sense.

The problem emerged when the practice scaled. Stack Overflow's 2025 Developer Survey found that 84% of respondents use or plan to use AI-assisted programming, but 46% expressed skepticism about AI-generated code accuracy. Only 3% said they "highly trust" AI output. Experienced developers were the most cautious, with 20% reporting high distrust.

The disconnect between adoption and trust created real consequences. Teams shipping vibe-coded output accumulated technical debt: broken tests, fragile abstractions, and code that no one on the team fully understood. The industry needed terminology that acknowledged AI's role without implying that human expertise was optional.

How agentic engineering works in practice

The workflow centers on a feedback loop between human oversight and autonomous agent execution. Here is how it typically operates in production teams:

Specification and constraints. The developer writes a natural-language specification or structured prompt defining requirements, edge cases, and testing expectations. This replaces the informal "just build me X" approach of vibe coding.

Agent orchestration. Tools like Claude Code, OpenAI Codex, or GLM-5 decompose the specification into subtasks. The agent generates code, writes tests, runs them, and iterates without requiring turn-by-turn guidance. Multi-agent systems can split work across specialized agents for frontend, backend, and testing.

Human review gates. The developer reviews agent output at defined checkpoints rather than after the fact. This includes code review, test validation, and architectural assessment. The key difference from vibe coding: the review is planned into the workflow, not an afterthought.

CI/CD integration. Agentic workflows plug into existing continuous integration pipelines. Agent-generated code goes through the same linting, testing, and deployment gates as human-written code. Organizations add specific guardrails for agent output, including mandatory test coverage thresholds and style compliance checks.

The tools powering agentic engineering

The tooling landscape has matured rapidly. In March 2026, the primary options span two categories:

Tool	Category	Approach
Claude Code	AI-enhanced IDE / CLI	Agent executes code, tests, iterates autonomously
OpenAI Codex	Agent-driven CLI	Background execution with human review checkpoints
Cursor	AI-enhanced IDE	Inline suggestions with agentic mode for larger tasks
GLM-5	Foundation model	Built specifically for agentic engineering patterns
Windsurf	AI-enhanced IDE	Flow-based agent with project-wide context

GLM-5, released in a February 2026 paper from Tsinghua University, explicitly positions itself as a model "designed to transition the paradigm of vibe coding to agentic engineering." It uses what the authors call DSA (dynamic structured agents) to break complex tasks into verifiable sub-components.

Simon Willison, creator of Datasette and a prolific writer on developer tooling, started documenting agentic engineering patterns in February 2026. His definition draws a clear line: agentic engineering is "building software using coding agents — tools like Claude Code and OpenAI Codex, where the defining feature is that they can both generate and execute code — allowing them to test that code and iterate on it independently of turn-by-turn guidance from their human supervisor."

Agentic engineering vs. vibe coding: a direct comparison

Dimension	Vibe coding	Agentic engineering
Human role	Minimal review	Active orchestration and oversight
Code quality	Unpredictable	Governed by review gates and CI/CD
Use case	Prototyping, throwaway scripts	Production systems, team workflows
Trust model	"Ship and hope"	Structured validation at checkpoints
Skill required	Basic prompting	System design, agent orchestration, review
Technical debt	High risk	Managed through guardrails

The distinction matters for hiring, team structure, and organizational risk. A team practicing vibe coding needs someone who can prompt effectively. A team practicing agentic engineering needs developers who understand system architecture, testing strategy, and how to design oversight loops for autonomous agents.

What organizations should do now

IBM's analysis identifies several concrete steps for teams adopting agentic engineering:

Establish governance frameworks. Define when and how agentic workflows should be used, and what review requirements apply to agent-generated code.

Train for orchestration, not just prompting. Engineers need to learn system design for agent workflows — how to break problems into agent-appropriate subtasks, set validation checkpoints, and integrate review loops into CI/CD.

Adopt RAG-based architectures. Ground agent output in real documentation, specifications, and code repositories. This reduces hallucination and improves accuracy by giving agents access to the actual codebase context.

Create internal playbooks. Standardize patterns for agent usage, including code-review requirements, testing expectations, and guardrail configurations specific to your stack.

Measure and iterate. Track metrics that matter: time-to-merge, defect rates on agent-generated vs. human-written code, and developer satisfaction with the workflow.

The open-source dimension

A January 2026 academic paper titled "Vibe Coding Kills Open Source" raised a concern that agentic engineering partially addresses. The paper argued that when developers stop engaging with the code AI generates, they also stop engaging with the open-source libraries that code depends on. Bug reports decrease. Contributions dry up. The social contract between developers and maintainers erodes.

Agentic engineering, with its emphasis on human review and understanding, offers a partial answer. Developers who actively review and understand agent-generated code remain engaged with the dependencies that code uses. But the concern is valid: the more autonomous the agent, the less visible the underlying infrastructure becomes to the developer overseeing it.

Key takeaways

• Agentic engineering is the practice of orchestrating AI coding agents under structured human oversight to build production software
• Karpathy coined the term in February 2026 to replace the casual connotations of "vibe coding"
• 84% of developers use AI-assisted programming but only 3% highly trust the output, making human oversight essential
• The workflow involves specification, agent orchestration, review gates, and CI/CD integration
• Tools like Claude Code, OpenAI Codex, and GLM-5 enable agents to write, test, and iterate code autonomously
• Organizations should establish governance frameworks, train for orchestration, and create internal playbooks

Conclusion

• Agentic engineering is the practice of orchestrating AI coding agents under structured human oversight to build production software
• Karpathy coined the term in February 2026 to replace the casual connotations of "vibe coding"
• 84% of developers use AI-assisted programming but only 3% highly trust the output, making human oversight essential
• The workflow involves specification, agent orchestration, review gates, and CI/CD integration
• Tools like Claude Code, OpenAI Codex, and GLM-5 enable agents to write, test, and iterate code autonomously
• Organizations should establish governance frameworks, train for orchestration, and create internal playbooks