On this pageOpenClose
Agentic engineering, not vibe coding
You can't ship faster than you understand.
A field guide for solo devs and small teams shipping code they own. The agent runs inside a harness: rules, tools, checks. This is the orientation; the next three chapters make it a working loop: Discovery, Implementation, Maintenance.
96% of developers don't fully trust AI-generated code.
Only 48% always verify it before committing.
The spectrum
AI work runs on a spectrum, not a switch.
The line isn't whether you use AI.
It's how outputs get verified.
Vibe coding
- Casual prompts
- "Seems to work?" is the check
- Often ships unread
- Best for: prototypes, scripts, hackathons
AI-assisted
- Detailed prompts + constraints
- Manual tests, spot-checks
- Review the critical paths
- Best for: features in known code
Agentic eng
- Specs + architecture docs
- Tests, CI/CD gates, quality evals
- Review the whole design
- Best for: production, code you'll maintain
Pick by the stakes, not by habit.
A config tweak or one-off? Skip the agent, just type it.
Weekend prototype? Vibe it. Payments API? Engineer it.
This playbook lives at that agentic end.
The economics
Speed is the wrong metric. Cost of ownership is the real one.
Cheap to start, expensive to own. Or pay upfront, and compound down.
Illustrative. The crossover is the argument: pay upfront, compound down.
AI multiplies output. Unharnessed, it outruns your ability to review:
+81%
duplicated code
−74%
refactoring: code rots untouched
+243%
incidents per PR
+54%
bugs
GitClear & Faros, 2026: risk scales with output, measured across AI broadly.
In plain terms: more code ships, but it's copy-pasted, breaks more, and goes unmaintained. Speed borrowed against next year.
A harness keeps each change small and reviewable. That's how you bend the curve.
What that buys you: fewer incidents, changes small enough to audit, code your next hire can maintain.
The harness
Agent = Model + Harness
Model: the reasoning. Claude, Codex, Gemini.
Harness: the scaffolding that keeps it bounded and reviewable.
A raw model isn't an agent.
The harness is what lets it finish something you can own.
- Prompt, paste, pray maps to Spec, run, verify
- Big unread diffs maps to Small reviewable tasks
- "Seems to work" maps to Tests and evidence
Six parts: instructions, tools, environment, control flow, guardrails, and observability (logs and traces). Unpacked in Implementation.
Treat agent failures as harness failures first. It's the part you control.
Two modes
Two modes, moved between by task: Conductor, you drive live; Orchestrator, you delegate, then review.
Conductor
- Real-time, synchronous, in-IDE
- You prompt, it generates, you review inline
- Keystroke-level control, instant feedback
- Single-file; you stay in the loop
- Best for: exploration, prototypes, learning an API
Orchestrator
- Asynchronous, high-level, multi-agent
- You define the task; agents run it
- Goal-level control, delayed feedback
- Multi-file; you review outcomes, not keystrokes
- Best for: features, migrations, test generation
Orchestrating lets you review outcomes, not keystrokes. But you still can't merge faster than you understand.
The three phases
Modes are how you work the agent. Phases are where the work is: planned, shipped, maintained.
Shape it, build it, improve it. Each cycle feeds the next.
Bottom line
Vibe coding versus agentic engineering comes down to comprehension plus a harness. Code you cannot maintain, debug, or defend is vibe-coded. The model writes the code. Your judgment owns the task and the review. The harness keeps the work bounded and reviewable.
Sources
- Sonar: State of Code Developer Survey (2026)
n=1,149 pro devs: 96% don't fully trust AI code, only 48% always verify it. The verification gap a harness closes.
- Google: The New SDLC With Vibe Coding (2026)
The paper this playbook adapts, and where the industry converges.
- Karpathy: Vibe coding (Feb 2025)
The post that named the casual end of the spectrum.
- Faros: AI Engineering Report 2026
AI adoption's measured bill: incidents/PR +243%, bugs +54%.
- Google DORA: 2025 State of AI-Assisted Software Development
AI amplifies your conditions; it won't fix broken engineering systems.
- GitClear: The Maintainability Gap (2026)
Duplicated code +81%, refactoring −74%: AI's ownership tax.
- METR: AI Developer Productivity (2026 update)
AI's task-level speedup is small and contested. Exactly why speed is the wrong metric.