In early 2025, Andrej Karpathy coined vibe coding — letting AI generate code while you half-watch, accepting what works, pasting errors back. A joke that landed because it was true.
Eighteen months later, three Google researchers — Addy Osmani, Shubham Saboo, and Sokratis Kartakis — published a ~50-page whitepaper that turns that meme into a methodology. The New SDLC With Vibe Coding , released June 2026 on Kaggle, is the first in a short series. It argues the term now covers everything from throwaway scripts to production-grade agentic engineering — and the difference is not the tooling, but how you verify the output. Here are the ideas that matter.
The Five Big Bets
The whitepaper advances five interconnected arguments, each challenging a core assumption the industry makes.
An agent is 10% model, 90% harness
The paper's central equation is simple: Agent = Model + Harness. The model is one input. Everything else — instructions, tools, MCP servers, sandboxes, orchestration logic, guardrails, observability — is the harness. The split, the authors estimate, is roughly 10% model, 90% harness.
Two examples make this concrete. On Terminal Bench 2.0, one team moved a coding agent from outside the Top 30 into the Top 5 by changing only the harness — the same model underneath. Separately, LangChain improved by 13.7% on the same benchmark by changing just the system prompt, tools, and middleware around a fixed model. Neither touched the model weights.
This reframes agent failures. When an agent does something dumb, the reflex is to blame the model. The paper argues most failures are configuration failures — missing tools, loose rules, absent guardrails. And configuration is the part you can fix today.
Context engineering is a first-class architectural decision
The paper sorts agent context into six types: instructions, knowledge, memory, examples, tools, and guardrails. The critical choice is which lives in static context (loaded every turn, expensive) versus dynamic context (loaded on demand, cheap). The pattern that makes dynamic context scale is Agent Skills with progressive disclosure — the agent sees a metadata manifest at startup, loads full instructions only when a task matches, and pulls reference material only when needed.
Verification is the line between vibe coding and engineering
The whitepaper draws a spectrum from Vibe Coding (casual prompts, "does it seem to work?", disposable code) through Structured AI-Assisted to Agentic Engineering (formal specs, automated evals, CI/CD gates, production systems at scale). The differentiator is not whether you use AI — it is how outputs get verified.
The paper identifies two mechanisms: Output evaluation (is the result correct?) and Trajectory evaluation (was the path sound?). You need both. An answer that looks right but skipped its checks is more dangerous than one that's obviously broken.
Set the bar at the eval, not the demo. A demo proves an agent can succeed once. An eval suite with a real rubric proves it succeeds reliably.
The SDLC phases change unevenly
AI compresses the lifecycle unevenly. Implementation drops from weeks to hours. Requirements, architecture, and verification stay slow because they are judgment work:
| Phase | What Changes |
|---|---|
| Requirements | A conversation producing a spec and prototype simultaneously |
| Architecture | "The most stubbornly human phase" — trade-offs need context models lack |
| Implementation | Surveys put gains at 25-39%; a METR study found developers going 19% slower on some tasks counting review time |
| Testing & QA | Evals become the primary way to tell the agent what "correct" means |
| Maintenance | Code "too risky to touch" can now be refactored by agents |
Maintenance is the sleeper win. Legacy code frozen because only its original authors understood it can now be modernized by agents.
The economics invert at scale
Vibe coding is cheap up front and expensive to run. A subscription gets you started; later you pay token burn, a maintenance tax from ad-hoc code, and security cleanup from fast-generated vulnerabilities. The paper estimates that past the crossover point, vibe coding costs 3-10x more per feature than agentic engineering. The levers that matter: context engineering (better first-pass success) and intelligent model routing (frontier models for hard problems, small models for routine work).
The Verification Bottleneck
The whitepaper's most consequential claim is not about generation. It is that verification has become the binding constraint on AI-augmented engineering. The paper argues generation is largely solved — and the hard problem is knowing whether the output is correct.
SonarSource's research found only 48% of developers consistently check AI-assisted code before committing, while 38% find reviewing AI logic harder than human-written code ( SonarSource, AI Coding Trust Gap ). The faster code is generated, the less it gets verified.
Anthropic's team found the same from a different angle. Agents evaluating their own work "reliably skew positive when grading their own output." Their solution: a generator-evaluator split — a separate skeptical agent that grades the generator's output ( Anthropic harness design ). The whitepaper describes an experiment where agents built a working C compiler in Rust over two weeks with this architecture, humans setting direction and reviewing rather than writing code ( Addy Osmani, blog summary ).
METR, meanwhile, found a different kind of verification problem: experienced developers went 19% slower on some tasks with AI — but their controlled study was breaking down because developers refused to participate without AI ( METR blog, Feb 2026 ). The selection effect means we are systematically undercounting both the gains and the verification costs.
What This Means for Developers and Leaders
The whitepaper closes with practical recommendations.
For individual developers, the shift is from writing code to specifying and verifying it. The paper describes two operating modes — the Conductor (real-time, in-IDE) and the Orchestrator (async, goal-driven). Google's Agents CLI embodies this: after uvx google-agents-cli setup, you say "Build a support agent. Evaluate it. Deploy it." — and the harness scaffolds, writes, evaluates, and deploys. Your role is to specify what "correct" looks like and verify the result.
Industry surveys estimate that as of early 2026, 85% of professional developers use AI coding agents regularly, 51% daily, and roughly 41% of new code is AI-generated ( Factory Model ). This is no longer an edge case.
For engineering leaders, the paper recommends investing in the harness as a shared asset — reusable prompts, skill libraries, MCP connections, and eval suites that compound across projects. Context engineering and model routing are cost levers, not just technical decisions. Route hard reasoning to frontier models and routine work to small, cheap ones. The quality holds and the bill comes down.
What the Whitepaper Leaves Open
The paper is candid about its limits. Chief among them is the 80% problem: agents get the first 80% of a feature fast, and the last 20% — edge cases, error handling, integration boundaries — requires context models don't have. The 80% shifts higher each model generation, but the remaining gap is qualitatively different. It is not about syntax anymore. It is about conceptual understanding the model cannot access.
Then there's the adoption gap. While 85% of developers use AI agents regularly, 44% now write less than 10% of their code manually (heavy users, per an Armin Ronacher poll), while 13% still write over 90% by hand ( Ronacher ). The split between early adopters and everyone else is widening. Those thriving have reconceptualized their role from implementer to orchestrator. Those struggling are using AI as a faster typewriter.
The whitepaper does not pretend to have solved these problems. As Addy Osmani writes:
"Generation is mostly solved now. The work that's left is specification and verification, and the systems that hold them together."
The blueprint is here. The execution is up to the industry.
Further Reading
- The New SDLC With Vibe Coding (full whitepaper on Kaggle) — 50 pages covering agent anatomy, context engineering, verification spectrum, and SDLC economics. First in a series.
- Addy Osmani's Blog Summary: The New Software Lifecycle — The co-author's distillation of the six ideas that matter most, with reusable figures. Essential companion reading.
- Agent Harness Engineering — Addy Osmani — Deeper treatment of the harness concept, with Terminal Bench results and the "skill issue" reframe of agent failures.
- Harness Design for Long-Running Applications — Anthropic — Independent validation of the generator-evaluator split from Anthropic's Labs team. Detailed account of a three-agent architecture building a retro video game maker and a Digital Audio Workstation over multi-hour sessions. Includes practical lessons on evaluator calibration.
- METR: Changing Developer Productivity Experiment Design — The study that found developers going 19% slower with AI on some tasks, alongside the selection effects that make these measurements unreliable. Essential nuance for the productivity debate.
- The 80% Problem in Agentic Coding — Addy Osmani — The companion piece on what happens after the first 80%. Covers comprehension debt, the productivity paradox, and the split between engineers who liked coding and those who liked building.
- SonarSource: The AI Trust Gap — Survey data showing only 48% of developers consistently check AI code, and 38% find AI-generated code harder to review than human-written code. The verification bottleneck in numbers.
No comments yet