From Vibe Coding to Agentic Engineering: What the Rebrand Actually Changes
Andrei Karpathy killed a term last week. 'Vibe coding' is a transition word, he said — the real name for what we're doing is 'agentic engineering.' He's right. And most teams aren't ready for what that name change demands.
From Vibe Coding to Agentic Engineering: What the Rebrand Actually Changes
Andrei Karpathy quietly killed a term last week. He called "vibe coding" a transition word — a placeholder for something that deserves a more precise name. His suggestion: agentic engineering.
He is right. And most engineering teams are not ready for what the name change demands.
Vibe Coding Was Never a Discipline
"Vibe coding" described a feeling. The engineer had a sense of what they wanted. They told the AI. The AI built something close. The engineer iterated until it felt right.
That process works for prototyping. It breaks down when the stakes change.
Production systems, customer data, billing logic, auth flows — these do not reward vibes. They reward precision, audit trails, and clear boundaries between what the AI decided and what the human approved.
The problem with the old term is that it implied the human was still in control through intuition. But teams were not building control systems. They were building on top of autonomous agents with no explicit oversight protocol.
What Agentic Engineering Actually Means
Agentic engineering names a specific activity: directing autonomous agents that write, test, and ship code with varying degrees of human oversight.
The distinction matters because it changes the design question.
Under "vibe coding," the question was: what should I tell the agent? Under "agentic engineering," the question becomes: what should the agent be allowed to do without asking me?
That second question is harder. It requires teams to define boundaries, build checkpoints, and create audit mechanisms. It requires the same rigor you apply to a contractor who can spend company money — not because they are untrusted, but because unchecked power at machine speed creates asymmetric risk.
The Real Shift: From Prompting to Oversight
The skill in agentic engineering is not prompting. It is knowing when to intervene, what to audit, and how to structure the agent's operating environment so that human judgment lands at the right moments.
This is not prompting technique. This is governance.
Three patterns I see work across the teams I advise:
One: Direction with scope constraints. Agents work fastest when they receive broad instructions. Agents cause incidents fastest the same way. Every session needs defined boundaries — module ownership, forbidden operations, required checkpoints before production access.
Two: Audit as a first-class output. Every agent session should produce a log entry: what it was told, what it decided to do, what it executed, what it changed. When the agent ships something wrong, you need to reconstruct the decision chain, not just the code.
Three: Escalation before action. The agent should treat ambiguous instructions as stop signals, not prompts to interpret. When the agent encounters a situation outside its defined rules, it pauses and asks. This is slower than letting the agent guess. It is vastly cheaper than the alternative.
The Agent Supervision Prompt
Here is the skill file I drop into every agent session before the first instruction. It makes the oversight contract explicit:
# Agent Supervision Rules
## Session Identity
You are working in a [project name] agent session.
Your role is to execute defined tasks under human direction. You are not autonomous beyond your assigned scope.
## Allowed Operations
- Write and edit files in your assigned module
- Run: tests, linters, type checkers, build commands
- Read any file in the repository
- Open a PR with your changes for human review
## Requires Explicit Approval Before Acting
- Any DELETE, DROP, or destructive database operation
- Infrastructure changes: provisioning, scaling, or configuration changes
- Dependency additions or version upgrades
- Credential or secret access
- Network or firewall rule changes
- Any operation touching production data or customer records
## Ambiguous Instruction Protocol
When you receive an instruction that is unclear or vague:
1. Do not guess or interpret liberally
2. Stop and ask a clarifying question
3. Wait for a specific directive before proceeding
4. Log the ambiguity: "Instruction unclear: [original text]. Awaiting clarification on [specific question]."
## Boundary Enforcement
You may not:
- Modify files outside your assigned module
- Execute shell scripts from unverified sources
- Access secrets outside of the designated secret manager
- Override the approval requirement for destructive operations
- Self-approve your own PR
## Escalation Path
Any situation outside these rules triggers an immediate stop.
Do not proceed. Do not guess. Notify the human: "I need human input before proceeding with [action]."
## Output Requirements
Before marking a task complete, produce:
1. Summary of changes made
2. Files modified
3. Tests run and results
4. Any errors encountered
5. Any ambiguities that arose during the session
This is a small file. It changes the agent's behavior significantly. Agents with explicit boundaries make fewer expensive mistakes. Not because the model is smarter, but because the operating environment constrains the blast radius.
Why the Name Change Matters
Names shape how teams think about problems. "Vibe coding" implied that AI-assisted development was intuitive, informal, and forgiving of imprecision. That framing let teams adopt the tools without building the operating model.
"Agentic engineering" is a precise term for a precise activity. It names the thing: you are directing agents. The agents act. Your job is to govern that action.
The teams winning with AI tools right now are the ones that treated the name change seriously. They built oversight protocols, defined agent boundaries, and treated the AI integration as an engineering problem, not a tooling decision.
The teams getting burned are the ones still vibes-coding in production.
Get the Full Agent Supervision Skill File
I posted the complete agentic engineering oversight framework on LinkedIn — including the full supervision prompt, the escalation checklist, and the audit logging template.
Comment "Guide" on that post and I will DM you the full skill file directly.
Work With Me
I help engineering orgs adopt AI across their entire team, not just the code, but how product, support, and operations work too. If you want your org moving faster without growing headcount, let's talk.
Kris Chase
@krisrchase