adventureonthewave

agentic-engineering

Agentic Engineering

Agentic engineering is building systems where AI agents do real work under real constraints: they write code, call tools, spend money, and touch production.

Doing it usefully is an engineering discipline — architecture, governance, review gates — not a prompting trick.

From demo to system

Anyone can get an agent to do something impressive once. The engineering question is what happens at fiftieth run: who reviews what it wrote, what happens when a tool misbehaves, where its memory lives, what it is allowed to touch, and what the weekly bill looks like.

My answer to those questions runs daily on my own systems and is documented across this site — not as theory but as a working rig with published metrics.

Vibe coding, agentic AI, agentic engineering

The three terms get used interchangeably. They are not the same thing, and the difference is not the model — it is what happens after the model answers.

Vibe coding — prompting an LLM and shipping whatever comes back. The term Andrej Karpathy coined in 2025. Perfectly fine for throwaway prototypes; unreviewable at team scale.

Agentic AI — the broader field: autonomous agents planning and executing tasks end to end. Software is one application among many — research, ops, support.

Agentic engineering — the discipline of putting agents to work under real constraints: architecture, isolation, review gates, budgets, merge authority. The subset of agentic AI that survives production.

Vibe codingAgentic AIAgentic engineering
What it isA prompt, shippedAgents executing tasks end to endAgents doing real work under real constraints
Unit of workThe promptThe taskThe governed PR
Who reviewsYou, if you feel like itVaries by deploymentA different model, then a human merge
Where it runsWherever the IDE opensSandboxes of varying hardnessIsolated worktrees, disposable environments
Failure modeUnreviewable code shipsWrong at scale, quietlyCaught at the gate
EvidenceScreenshotsDemosPublished metrics

The four pillars here

The operating principle

Agents build. A different model reviews. Humans merge.

Everything on this site reduces to that line. It is the difference between an AI demo and an AI system, and it is enforced by guardrails, not by good intentions. The full mechanics live in deployment guardrails and the evidence in the Turbo Rig case study.

What an agentic engineer does

The job changes shape. Less typing code, more designing the system the code gets written inside:

The stack, by role

Tools rotate monthly. The seats don't. Everything in the current rotation maps to exactly one seat in the build–review–merge pipeline:

FAQ

What is agentic engineering, in one line?

Building systems where AI agents do real work under real constraints — code, tools, money, production — with the architecture and governance to survive all four.

How is agentic engineering different from vibe coding?

Vibe coding ships what the model returns. Agentic engineering assumes the model will be wrong at fiftieth run and gates for it: isolation, cross-model review, and human merge authority.

Do agents replace engineers?

No. They move the work. In the audited week of September 21–28, 2026, my rig merged 180 PRs across 16 repositories — every merge a human decision, with 967 gate reviews running first. The engineers who disappear are the ones whose only skill was typing what an agent now types.

What does a governed agentic workflow look like?

One shared shape: plan → research → PRD → ADRs → build → cross-model review → human merge. The mechanics are on coding agents; the three artifacts behind it are on the governance framework.

How do you stop an agent from breaking production?

Four mechanisms, in order: isolation (worktrees and disposable environments), a permissions matrix with named enforcement, budget caps, and a review gate where a missing verdict counts as a rejection. Detail in deployment guardrails.

Does this only apply to writing code?

Code is where it pays fastest, but the pattern — agents build, a different model reviews, humans hold the irreversible authority — applies anywhere agents take actions that cost money or touch live systems: infrastructure, data, ops.

Talk it through with someone who runs this stack on his own systems every day.