What Is Agentic Engineering? The Discipline Replacing Vibe Coding

Agentic engineering is the discipline of building software by directing AI coding agents, agents that both generate and execute code, inside a process with real engineering controls. Concretely, that means five things: work is defined in a written spec before any code exists; a human approves the plan before an agent starts; each agent runs in isolation, on its own branch or worktree, so parallel work cannot collide; agents verify their output against stated acceptance criteria, usually by running tests; and every change lands as a pull request a human reviews.

The word “engineering” is doing real work in that sentence. The agents are not new, what is new is treating them the way a good team treats any powerful, fallible contributor: with scoped assignments, checkpoints, and review. The human role shifts from writing implementation code to defining work, supplying context, and judging results, the same shift a senior engineer makes when they start leading instead of just committing.

The term's origin story is unusually tidy, because the same person named both eras. Andrej Karpathy coined vibe coding in February 2025: give in to the vibes, accept the diffs, fine for throwaway projects. Then, in early 2026, he declared his own coinage passé and proposed agentic engineering as the successor, a move that was widely covered precisely because it came from the source. At Sequoia's Ascent event in April 2026, he framed the relationship memorably: vibe coding raises the floor, letting anyone produce working software, while agentic engineering raises the ceiling, letting professionals produce more of it, reliably. In May 2026 he joined Anthropic's pre-training team, which kept the framing in circulation.

The term did not stay his. IBM has published its own definitional take, and Simon Willison, whose blog is a primary source for this space, frames agentic engineering around a specific capability: agents that both generate and execute code, orchestrated with engineering rigor rather than accepted on faith. The definitions differ at the edges but agree on the core: the discipline is in the orchestration, not the generation.

Definitions are cheap; practices are what you actually do on Monday. Six recur across every serious treatment of the term, and each has a full deep-dive on this site:

1. 1

   Spec-first work

   Every task starts as a written spec, scope, files, acceptance criteria, exclusions, that the agent implements against and the reviewer reviews against. This is the single highest-leverage practice, covered in spec-driven AI development.
2. 2

   Context engineering

   Agents are only as good as what they can see. Deciding which files, conventions, memory, and documentation reach the agent, and keeping noise out, is a craft of its own: context engineering for coding agents.
3. 3

   A harness of conventions

   Raw agents need guardrails: how to name branches, when to run tests, what never to touch, how to report progress. The recurring wrapper is what we call the AI agent harness.
4. 4

   Parallel isolation

   Multiple agents on one working copy is chaos; one git worktree per task makes parallelism safe and merges clean. The mechanics live in parallel agents with git worktrees.
5. 5

   Verification loops

   The agent runs the test suite, reads failures, and iterates before handing off. Verification is what separates an agent that executes code from one that merely emits it, and it only works when the spec defined something verifiable in the first place.
6. 6

   PR review as the unit of human judgment

   Humans review finished pull requests against the spec, not keystrokes in a chat window. The end of the loop, from story to described, reviewable PR, is covered in AI PR automation.

The two terms describe the same tools used with opposite intent. The short version, the full treatment lives in vibe coding vs agentic engineering:

Terms stick when something real changes underneath them, and something did. Through 2024 and 2025, the bottleneck in AI-assisted development was generation quality: could the model write correct code at all? By 2026, frontier coding agents got good enough that generation largely stopped being the constraint. The bottleneck moved up a level, to orchestration: how do you keep five capable agents from colliding, how do you review ten PRs a day without rubber-stamping, how do you make sure what got built is what you meant?

Those are engineering-management problems, not prompting problems, which is why the vocabulary shifted from “coding” to “engineering”. It is also why the practices above look suspiciously like classic software process, specs, gates, isolation, review, applied to a new kind of contributor. Whether the label itself outlives 2026 matters less than the shift it names; we track the label's trajectory in is vibe coding dead? and the broader workflow argument in engineering with AI agents.

You can run every practice above by hand: write specs in markdown, manage worktrees from the terminal, track agents in your head. AIDEN exists because the bookkeeping is exactly the kind of work software should do. It is a macOS desktop app that orchestrates your local Claude Code and Codex CLIs on a kanban board where every card is a story with a spec, a branch, and a status.

It is free for one project, so the cheapest way to evaluate agentic engineering is to run one real story through the loop and review the PR it produces.