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 coding | Agentic AI | Agentic engineering | |
|---|---|---|---|
| What it is | A prompt, shipped | Agents executing tasks end to end | Agents doing real work under real constraints |
| Unit of work | The prompt | The task | The governed PR |
| Who reviews | You, if you feel like it | Varies by deployment | A different model, then a human merge |
| Where it runs | Wherever the IDE opens | Sandboxes of varying hardness | Isolated worktrees, disposable environments |
| Failure mode | Unreviewable code ships | Wrong at scale, quietly | Caught at the gate |
| Evidence | Screenshots | Demos | Published metrics |
The four pillars here
- Agentic platform engineering — the architecture: perception, reasoning, action, memory, governance as one platform model.
- Coding agents — deploying AI coding agents across a team safely: environments, isolation, and workflow.
- AI code review — the cross-model review gate that keeps agent-written code honest.
- Agent governance — permissions, policy, constitutions, and human merge authority.
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:
- Designs the workflow — plan → research → PRD → ADRs → build, one shared shape for every agent and every human.
- Writes the constitution — the rules agents run under, versioned and enforced in config, not convention.
- Wires the review gate — a different model reviews every PR, and a missing verdict is a rejection.
- Owns the platform — isolation, permissions, memory, budgets: the surfaces agents touch and the limits they hit.
- Reads the metrics, makes the merge call — merge authority stays human, and the decision runs on published numbers, not vibes.
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:
- Builders — Claude Code, Cursor, Roo Code, Replit Agent. Run isolated in worktrees and disposable environments, never directly on shared state.
- Reviewer — a second model family, never the one that wrote the code. Every PR, no exceptions.
- Orchestration — SPARC, Claude swarms, Composio, OpenRouter: who runs, in what order, with which tools.
- Platform — Kubernetes, ArgoCD, Helm, Terraform, Coder, GitOps: the substrate agents build and deploy onto.
- Measurement — PR counts, review outcomes, tokens, cost, cache hit rate. Published, not guessed. Last audited week: 180 merged PRs, 967 gate reviews, a 96.5% prompt-cache hit rate.
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.