The Study · Explainer
In May 2026 Google published a 51-page whitepaper called The New SDLC With Vibe Coding, written by Addy Osmani, Shubham Saboo, and Sokratis Kartakis, and then taught it to over a million people through a free five-day course in June. Its argument in one line: the software lifecycle keeps its phases, loses its old bottleneck, and gains a new one. Writing code is no longer the expensive part. Specifying, verifying, and judging what the machine wrote is. We read the full paper, checked its numbers against their primary sources, and pulled out what it means for a builder working alone.
The short version #
The paper’s core move is a spectrum. Vibe coding and agentic engineering are endpoints of one practice, and the position on the line is set by how much verification surrounds the AI’s output. The tools can be identical at both ends.Its most useful equation is agent = model + harness. The paper puts the split at roughly 10% model and 90% harness, and the receipt behind that claim is real: LangChain moved a coding agent from outside the top 30 to the top 5 on a public benchmarkwithout changing the model.The lifecycle keeps its shape and changes its proportions. Implementation compresses from weeks to hours; requirements, architecture, and review stay human-paced. Specification quality is the new bottleneck, and tests plus evals become how you tell the AI what correct means.Read its statistics with the flags on. The framework is sound, and the paper’s headline adoption numbers cite marketing aggregators rather than the primary surveys that actually exist. We traced each one below; some hold, some are softer.For a solo builder, the six-step starting list is the payload. An AGENTS.md, one repetitive workflow turned into an agent, tests before generation, and a review pass on every line that ships.
The rest is the framework in detail, with the sources open.
What the paper is, and where to find it #
The whitepaper is the first entry in a series Google shipped alongside its 5-Day AI Agents intensive, the free Kaggle course whose November 2025 edition reached more than 1.5 million learners. The paper itself is hosted on Kaggle, dated May 2026, 51 pages with 32 endnotes. Osmani, its lead author, published a condensed companion essay on O’Reilly Radar in July, which is the version most people have actually read.
The timing explains why the searches spiked. The term vibe coding is Andrej Karpathy’s, from February 2025, and it stretched within months to mean any AI-assisted coding at all. By April 2026 Karpathy himself drew a new line at Sequoia’s AI Ascent, introducing agentic engineering as the disciplined end of the practice: vibe coding raises the floor of who can build software, agentic engineering raises the ceiling of what professionals ship. The Google paper is the institutional version of that split, with a course attached.
The spectrum, which is the actual answer #
The paper refuses the binary. Vibe coding and agentic engineering are endpoints on a spectrum, and the differentiator is stated plainly: what decides your position is how outputs get verified, and nothing else. A developer can vibe code and practice agentic engineering with the same agent in the same afternoon.
At the loose end, casual prompts, no reading of the generated code, and a verification standard of “does it seem to work.” The paper is comfortable with this mode where the code is disposable: prototypes, scripts, hackathons. The middle is where most working builders live, detailed prompts and manual spot-checks on features inside an established codebase. The far end is formal specs, automated test suites, CI/CD gates, and LLM judges, with humans reviewing architecture while the AI handles implementation detail.
Two things about this framing earn their keep. First, it gives you a clean answer to a question clients and CTOs are already asking; the paper notes that telling a CTO you vibe coded the payment system should raise alarms, while describing the same AI leverage under constraints and test coverage is a different conversation. Second, it puts the boundary inside your control. Verification is a budget you spend by the stakes of each task, the same supervised-beats-unattended split the agent research keeps finding. The paper’s own line is that without tests and evals together, the practice is always vibe coding, no matter how sophisticated the prompts.
An academic taxonomy published a year earlier drew nearly the same map from the outside, splitting conversational, human-in-the-loop building from goal-driven autonomous execution across twenty use cases. The convergence is a good sign the distinction is real rather than branding.
Agent = model + harness #
The paper’s second framework is the one with a receipt attached. An agent is a model plus a harness, where the harness is everything wrapped around the reasoning engine: instruction files, tools and MCP servers, sandboxes, orchestration logic, guardrails, hooks, and observability. The paper’s rough split gives the model 10% of the outcome and the harness 90%, and its sharpest sentence follows from it: most agent failures, examined honestly, are configuration failures. When the agent does something wrong, the instinct is to blame the model, and the fix is usually a missing tool, a vague rule, or a context window stuffed with noise.
The evidence is worth stating precisely, because the paper cites it loosely. In February 2026 LangChain rebuilt the harness around a fixed model and lifted its score on Terminal-Bench 2.0 from 52.8% to 66.5%, a 13.7-point gain that carried the agent from outside the top 30 to the top 5 on the leaderboard. They changed the system prompt, the tools, and the middleware, and touched nothing else. The whitepaper presents the rank jump and the point gain as two separate results from two teams; they are one experiment, one team, one receipt. The receipt is strong. It is also singular, and it deserves counting once.
For a solo builder this section is the practical center of the paper. Your CLAUDE.md or AGENTS.md, your test commands, the rules you add every time the agent repeats a mistake: that unglamorous file is the harness, it compounds, and it is yours rather than the model vendor’s. The searches rising around the paper, harness engineering among them, suggest the market is catching on to where the leverage sits.
The lifecycle, phase by phase #
The paper’s SDLC chapter keeps the traditional six phases and redistributes the time inside them. Requirements stop being a handoff document and become a conversation that produces a spec and a working prototype in the same sitting. Architecture stays, in the paper’s phrase, stubbornly human, because trade-offs depend on business context the model does not hold. Implementation compresses from weeks to hours. Testing inverts into the steering wheel: a well-written test and eval suite is how you communicate intent to the agent, checked two ways, output evaluation for whether the result is right and trajectory evaluation for whether the path there was sound. Review gains an AI first-pass but keeps human judgment on design and maintainability. And maintenance, the paper argues, is the most underestimated shift, because codebases that were too risky to touch can now be navigated and refactored with an agent that respects the existing architecture.
The mental model tying it together is the factory: the developer’s primary output stops being code and becomes the system that produces code, specs, agents, quality gates, feedback loops, and guardrails. You design the assembly line and audit its output instead of assembling every widget by hand.
The honest caveat lives right in the paper: a note admits the phase boundaries reflect mid-2026 and may look different within twelve months. Hold the framework, not the diagram.
The numbers, checked #
This is the part of the paper we are equipped to referee, because we have verified most of the underlying research before. The framework survives the check. Some of its statistics need flags the paper does not carry.
The opening claim, 85% of professional developers regularly using AI coding agents, 51% daily, 41% of new code AI-generated, carries a single endnote, and that endnote points to two marketing statistics roundups, GetPanto and Index.dev, rather than any primary study. The strange part is that real primaries exist and are stronger. Stack Overflow’s 2025 survey of 49,009 developers found 51% of professionals using AI tools daily, which is presumably where the aggregators got it. Google’s own DORA 2025 report puts adoption at 90% among nearly 5,000 respondents. The adoption story is true and citable one link deeper than the paper goes. The 41% AI-generated share is the one we could not trace to any primary source at all; treat it as an industry estimate, the same way we treat company-disclosed revenue.
The productivity range, 25 to 39% per industry surveys, cites two vendor blog posts, with a Deloitte projection of 30 to 35% in a neighboring endnote. Projections and vendor surveys are the softest tier of evidence there is; the controlled trials we have verified separately run 26% to 56% on fresh builds, so the direction is right even where the citation is thin. The paper’s METR sentence, experienced developers 19% slower once verification time is counted, is a real result and deserves its context: sixteen expert maintainers on mature repositories they knew intimately, using early-2025 tools, with METR’s own February 2026 update reading newer data as weak evidence the speedup has arrived. And the economics chapter’s claim that past the crossover vibe coding costs 3 to 10x more per feature is labeled here plainly: that number illustrates a curve in a figure, measured by no study we could find.
None of this sinks the paper. It means the paper is best read as a framework document with a statistics garnish, and the framework is the part built to last. An independent practitioner review reached the same verdict from the operations side: right about the shift, too clean about the friction.
The economics, sized for one person #
The chapter most relevant to this site’s beat recasts the spectrum as a cost structure. Vibe coding is low CapEx, high OpEx: nothing upfront, then a compounding bill in token burn from fix-it-again loops, maintenance on structurally inconsistent code, and security remediation after the fact. Agentic engineering is the inverse, high CapEx, low OpEx: you pay upfront in specs, tests, and context design, and the marginal feature gets cheap because the agent’s first pass lands more often.
We would add the solo builder’s corollary the paper leaves implicit: the two cost structures are a sequence, and the crossover has a name, validation. Vibe code while the idea is unproven, because speed-to-signal is the only metric and the code is disposable by design. The day real users arrive, the OpEx curve starts compounding, and that is the day the harness investment, the tests, the AGENTS.md, the cleanup pass you schedule like an oil change, becomes the cheapest money in the budget. The paper also endorses model routing as a cost lever, big models for architecture and first implementation, small cheap ones for test generation and review, which is the same token arithmetic that governs any product wrapping an LLM.
What to actually do #
The paper closes with adoption lists, and the individual-developer one is genuinely good, so here it is, compressed and reordered for someone shipping alone with a working stack:
Write the ten-line AGENTS.md today. Stack, conventions, hard rules, workflow. Add a rule every time the agent repeats a mistake, and the file becomes your compounding asset.Turn one repetitive workflow into your first agent. A research loop, a review pass, a recurring report. Building one end to end teaches more than reading about a hundred.Write the tests and evals before generating the code. They are the contract; a good suite communicates intent more precisely than any prompt.Review every line that ships. Be skeptical of anything clever, check that imports name real packages, and confirm error handling covers realistic failures. Code you do not understand is debugging cost you cannot afford.Keep your own skills sharp. The arrangement only works while your debugging and design judgment stay strong enough to referee the output.
The paper’s closing principles say the quiet part well: structure scales and vibes do not, AI amplifies whatever engineering culture it lands in, and the human role is shifting from implementation to judgment. Its final sentence is the whole document in ten words: “Generation is solved. Verification, judgment, and direction are the new craft.” That matches every number we have checked, in this piece and the ones before it. The builders who win the next stretch are the ones who take the free speed and then buy the verification with it.
One email, when there's something worth sending
Get the research in your inbox. #
No fixed schedule, no filler. You get an email when we've tested something, run the numbers, or found a tool worth your time.
Free. Double opt-in, unsubscribe in one click.
Where do you sit on the spectrum? Compare notes in the forum ↗
Sources & how we researched this #
- Google (May 2026), 'The New SDLC With Vibe Coding: From ad-hoc prompting to Agentic Engineering,' by Addy Osmani, Shubham Saboo, and Sokratis Kartakis. 51 pages, published on Kaggle. kaggle.com/whitepaper-the-new-SDLC-with-vibe-coding
- Google blog (June 2026), '5-Day AI Agents: Intensive Vibe Coding Course' announcement, June 15 to 19 cohort; the November 2025 run reached 1.5M+ learners. blog.google
- Addy Osmani (July 15, 2026), 'The New Software Lifecycle,' the whitepaper's companion essay. oreilly.com/radar and addyosmani.com
- Andrej Karpathy (Feb 2025), the original vibe coding post. x.com/karpathy/status/1886192184808149383
- Andrej Karpathy (April 30, 2026), Sequoia AI Ascent talk and his own summary post introducing 'agentic engineering.' karpathy.bearblog.dev/sequoia-ascent-2026
- LangChain (Feb 17, 2026), 'Improving Deep Agents with harness engineering': Terminal-Bench 2.0, 52.8% to 66.5% with the model held fixed. langchain.com/blog
- Stack Overflow 2025 Developer Survey (49,009 respondents): 51% of professional developers use AI tools daily. survey.stackoverflow.co/2025
- Google Cloud DORA (2025), 'State of AI-assisted Software Development' (~5,000 respondents): 90% use AI at work, 30% report little or no trust in AI output. dora.dev/dora-report-2025
- METR (July 2025), randomized trial: experienced open-source maintainers 19% slower with early-2025 AI tools. metr.org / arxiv.org/abs/2507.09089
- METR (Feb 2026), Uplift study update: newer data read as weak evidence of speedup. metr.org/blog/2026-02-24-uplift-update
- GetPanto and Index.dev statistics roundups, the whitepaper's endnote 1 for its adoption figures (aggregator pages, flagged as such in this piece).
- Sapkota, Roumeliotis & Karkee (May 2025), 'Vibe Coding vs. Agentic Coding: Fundamentals and Practical Implications of Agentic AI.' arxiv.org/abs/2505.19443
- The Lazy SRE (June 28, 2026), 'I Read Google's The New SDLC So You Don't Have To,' an independent practitioner review. thelazysre.com