# osmani-google-new-sdlc-vibe-coding-agentic-engineering-2026-05 ## Veille Google whitepaper (the "Day 1" installment of a series, by Addy Osmani, Shubham Saboo and Sokratis Kartakis) mapping the transformation of the software development lifecycle (SDLC) in the age of coding agents. Thesis: the fundamental shift is not a new language but the move from writing code to **expressing intent**. The document sets out a spectrum ranging from *vibe coding* (prompting and accepting) to *agentic engineering* (AI implements under constraints, tests, and feedback loops designed by humans), with **context engineering** as the central skill, the **software factory** model (the developer's deliverable = the system that produces the code), **harness engineering** (Agent = Model + Harness), and a CapEx/OpEx economic analysis of total cost of ownership. ## Titre Article The New SDLC With Vibe Coding — From ad-hoc prompting to Agentic Engineering ## Date 2026-05 ## URL https://www.kaggle.com/whitepaper-the-new-SDLC-with-vibe-coding ## Keywords new SDLC, vibe coding, agentic engineering, agentic engineering, intent vs syntax, context engineering, context engineering, static vs dynamic context, Agent Skills, harness engineering, Agent = Model + Harness, software factory, factory model, agent loop, evals, trajectory evaluation, conductor vs orchestrator, 80% problem, AGENTS.md, CLAUDE.md, GEMINI.md, MCP, A2A, Agents CLI, ADK, model routing, CapEx OpEx, total cost of ownership, token economy, Google, Addy Osmani ## Authors Addy Osmani, Shubham Saboo, Sokratis Kartakis (Google) ## Ton Profile: corporate whitepaper (Google), "we"-perspective of practitioner-authors, didactic-strategic register in English, high technical level but deliberately accessible (the document specifies it targets engineers, managers, architects, and technical leaders familiar with modern development but not with ML). The tone combines the authority of the Google brand, that of Addy Osmani (a well-known figure in web engineering, extensively self-cited in the endnotes), and a sustained pedagogical effort: each concept is introduced with a definition, illustrated by a numbered figure (9 figures), and anchored in quantitative data and public benchmarks. Structured in movements (from syntax→intent, to the spectrum, to context, to the new SDLC, to the harness, to roles, to practice, to economics, to recommendations), with sustained, effective metaphors: the **factory manager** who designs the pipeline rather than assembling each part, the **engine** (model) vs **the car, the road, and the rules of the road** (harness), the **conductor vs the orchestrator**. A deliberate balance between promise (25-39% gains) and nuance (METR study: -19%, "80% problem"). A framing document that claims durable principles rather than a perishable snapshot. ## Pense-betes - **Pivotal thesis**: *"The most profound shift in software engineering isn't a new language, framework, or cloud service. It's the transition from writing code to expressing intent."* The developer's interface shifts from **syntax** to **intent**. - **Framing data (2026)**: **85%** of professional developers regularly use coding agents, **51%** daily, **41%** of new code is AI-generated. - **Figure 1 — From Autocomplete to Autonomy**: 5 cumulative generations (Autocomplete ~2021 → Inline suggestions ~2022 → Chat-based generation ~2023 → Coding agents ~2024-25 → Autonomous agents ~2025-26), Syntax → Intent axis, *"more human effort"* → *"more machine autonomy"*. - **The agent = loop**: perceive goal → plan → act (tools) → observe → iterate (self-correction). Built from **5 parts** (see whitepaper *Introduction to Agents*, Nov. 2025): model, tools, memory, orchestration, deployment. *"The loop is the beating heart of every agent."* - **Vibe coding**: a term coined by Karpathy (Feb. 2025, *"fully give in to the vibes"*); applied so broadly it lost its meaning → in early 2026 Karpathy introduced **agentic engineering** for the disciplined end of the spectrum. - **The spectrum** (vibe coding ↔ structured AI-assisted ↔ agentic engineering): *"the key differentiator is not whether you use AI. It's how much structure, verification, and human judgment surrounds the AI's output."* - **Verification = the real differentiator**: **Tests** verify the deterministic (input→output); **Evals** verify the non-deterministic (right trajectory? right tools? quality-level response?), via labeled datasets, scoring rubrics, **LM judges**. *"Without both, the practice is always vibe coding, regardless of how sophisticated the prompts are."* - **Context engineering = the real skill**: code quality depends less on prompt refinement than on the quality of the **context**. **6 types**: Instructions, Knowledge, Memory, Examples, Tools, Guardrails. Trade-off between **static context** (always loaded: AGENTS.md/CLAUDE.md/GEMINI.md — costly) and **dynamic context** (loaded on demand: skills, RAG, tool results — efficient). - **Agent Skills** = the most powerful pattern for dynamic context (progressive disclosure: metadata at startup, instructions on match, references on demand). Solves 4 problems: **context rot**, lack of procedural memory, multi-agent operational overhead, cross-tool portability. - **The new SDLC**: AI **compresses the cycle unevenly** — implementation shrinks from weeks to hours, but requirements/architecture/verification remain at human pace. *"It is not a faster version of the old SDLC. It is a different workflow."* The developer shifts from *primary implementor* to *system designer & quality arbiter*. - **By phase**: Requirements (collapse requirements→prototype); **Design/architecture = the most stubbornly human phase** (trade-off decisions); Implementation (gains of **25-39%**, tempered by the **METR study: experienced developers 19% slower** on certain tasks due to verification); Testing (output eval + **trajectory evaluation**); Code review (AI as *first-pass reviewer*); Maintenance ("too risky to touch" technical debt becomes refactorable). - **Factory model**: *"the developer's primary output is not code — it's the system that produces code"* (specs + agents + tests/quality gates + feedback loops + guardrails). The developer designs the pipeline and quality control, not each individual part. - **Harness Engineering**: *"Agent = Model + Harness"*. The model ≈ **10%**, the harness ≈ **90%**. Contents: instructions/rule files, tools/MCP, sandboxes, orchestration (sub-agents, routing, hand-offs), guardrails/hooks (deterministic code at lifecycle points), observability. *"This surrounding machinery is known as the Harness."* - **Evidence of the harness effect**: on **Terminal Bench 2.0**, one team moved an agent **from outside the Top 30 to the Top 5 by changing only the harness** (model unchanged); **LangChain: +13.7 points** by touching only the system prompt/tools/middleware. *"Most agent failures, examined honestly, are configuration failures."* - **Developer roles**: **Conductor** (real-time, synchronous, in-IDE, keystroke-level control — Copilot/Gemini Code Assist/Cursor/Windsurf) vs **Orchestrator** (async, multi-agent, goal-level control — Jules/Cursor background/Claude Code). *"Not either/or — both, depending on the task."* - **The 80% problem**: AI quickly generates ~80% of the code; the remaining **20%** (edge cases, error handling, integration, subtle fixes) demand deep contextual knowledge. AI errors have shifted from syntax mistakes to **conceptual failures** (the code *"looks right"* and passes basic tests). - **Agents in practice — 3 locations**: *in the editor* (Copilot, Cursor, Windsurf, JetBrains), *in the terminal* (Antigravity CLI, Claude Code, Codex CLI, Open Code, Cline), *in the background* (Jules, Cursor background, AlphaEvolve). **Vibe coding of production agents** via **Google Agents CLI** (`agents-cli create/playground/eval/deploy`, ADK lifecycle), **MCP** (tools) + **A2A** (inter-agent delegation). Anthropic: agent teams that built a **C compiler in Rust in 2 weeks**. - **Economics (CapEx/OpEx)**: **vibe coding = low CapEx, high OpEx** (token burn, maintenance tax, security remediation); **agentic engineering = high CapEx, low OpEx** (upfront investment in specs/tests/context → collapsed marginal delivery cost). **Context engineering = a financial lever**; **intelligent model routing** (large models for requirements/architecture, small models for tests/review/CI). Figure 9: crossover point where vibe coding costs **3-10× more per feature**. - **Conclusion — 3 durable principles**: (1) *"Structure scales, vibes don't"*; (2) *"AI amplifies your engineering culture"* (a force multiplier for strengths AND weaknesses); (3) *"The human role is evolving, not diminishing"*. Closing line: ***"Generation is solved. Verification, judgment, and direction are the new craft."*** - **Series**: Day 1 (this document); **Day 3** = *Context Engineering: Sessions, Skills & Memory*; **Day 5** = *Spec-Driven Production Grade Development in the Age of Vibe Coding* (code review, guardrails, zero-trust). ## RésuméDe400mots This Google whitepaper (the first installment of a series, authored by Addy Osmani, Shubham Saboo and Sokratis Kartakis, May 2026) argues that the deepest transformation in software engineering is not technological but interfacial: the shift is from writing code to expressing intent, entrusting intelligent systems with translating that intent into working software. Framing data: 85% of professional developers regularly use coding agents, 51% daily, and 41% of new code is AI-generated. The authors reject the binary opposition between vibe coding and agentic engineering in favor of a **spectrum**. The differentiator is not whether AI is used but the amount of structure, verification, and human judgment surrounding its output. Key distinction: **tests** verify the deterministic, **evals** (labeled datasets, rubrics, LM judges) verify the non-deterministic — without both, the practice remains vibe coding. The central skill becomes **context engineering**: code quality depends less on prompt refinement than on the quality of the context provided. Six types of context (instructions, knowledge, memory, examples, tools, guardrails) split between **static** context (always loaded, costly: AGENTS.md, CLAUDE.md, GEMINI.md) and **dynamic** context (loaded on demand, efficient). **Agent Skills** are the flagship pattern for dynamic context via progressive disclosure. The SDLC is compressed unevenly: implementation shrinks from weeks to hours, but requirements, architecture, and verification remain at human pace. Architecture stays the most stubbornly human phase (trade-off decisions). On the implementation side, gains of 25-39%, tempered by the METR study (experienced developers 19% slower on certain tasks). The throughline is the **factory model**: the developer's deliverable is no longer the code but the system that produces it (specs, agents, quality gates, feedback loops, guardrails). At the heart of the factory sits the equation **Agent = Model + Harness**: the model accounts for ~10%, the harness ~90% (instructions, tools/MCP, sandboxes, orchestration, hooks, observability). Evidence: on Terminal Bench 2.0, changing only the harness moved an agent from outside the Top 30 to the Top 5. *"Most agent failures are configuration failures."* The developer moves between **conductor** (real-time, in-IDE) and **orchestrator** (async, multi-agent), confronting the **80% problem**. Economically, vibe coding (low CapEx/high OpEx) ends up 3-10× more expensive per feature than agentic engineering (high CapEx/low OpEx); context engineering and model routing are financial levers. Conclusion: *"Generation is solved. Verification, judgment, and direction are the new craft."* ## GrapheDeConnaissance - Google —publie→ The New SDLC With Vibe Coding (DOCUMENT, 0.97) - Addy Osmani —a_créé→ The New SDLC With Vibe Coding (DOCUMENT, 0.95) - The New SDLC With Vibe Coding —affine→ SDLC (METHODOLOGIE, 0.9) - Addy Osmani —travaille_chez→ Google (ORGANISATION, 0.95) - The New SDLC With Vibe Coding —affirme_que→ le basculement fondamental est le passage de l'écriture de code à l'expression d'intention (AFFIRMATION, 0.96) - agentic engineering —est_variante_de→ vibe coding (METHODOLOGIE, 0.9) - context engineering —améliore→ qualité du code généré par IA (CONCEPT, 0.93) - Agent Skills —permet→ gestion du contexte dynamique par progressive disclosure (CONCEPT, 0.92) - Agent Skills —réduit→ context rot des prompts surchargés (CONCEPT, 0.88) - harness —permet→ transformer un modèle brut en agent capable de finir une tâche (CONCEPT, 0.93) - The New SDLC With Vibe Coding —affirme_que→ la plupart des échecs d'agents sont des échecs de configuration du harness (AFFIRMATION, 0.91) - IA —réduit→ durée de la phase d'implémentation (CONCEPT, 0.9) - modèle de l'usine —affirme_que→ le livrable du développeur n'est pas le code mais le système qui produit le code (AFFIRMATION, 0.93) - evals —s_applique_à→ vérification des comportements non déterministes des agents (CONCEPT, 0.9) - Andrej Karpathy —a_créé→ vibe coding (METHODOLOGIE, 0.92) - Andrej Karpathy —a_créé→ agentic engineering (METHODOLOGIE, 0.85) - Google Agents CLI —utilise→ lifecycle ADK pour construire des agents de production (CONCEPT, 0.88) - intelligent model routing —réduit→ coût opérationnel en tokens (OpEx) (CONCEPT, 0.89) - vibe coding —s_applique_à→ prototypes, scripts et projets jetables (CONCEPT, 0.9) - The New SDLC With Vibe Coding —affirme_que→ Generation is solved. Verification, judgment, and direction are the new craft (CITATION, 0.95) - The New SDLC With Vibe Coding —mesure→ 41 % du nouveau code est généré par IA en 2026 (MESURE, 0.9) --- Canonical: https://www.thekb.eu/en/fiches/osmani-google-new-sdlc-vibe-coding-agentic-engineering-2026-05/