The New SDLC: From Vibe Coding to Agentic Engineering

For most of computing history, programming has been an act of translation. You understand the problem in human terms, design a solution in abstract terms, then render it in syntax a machine can execute. Each step introduces friction. That friction is now collapsing.

A new whitepaper from Google Research — "The New SDLC with Vibe Coding" by Addy Osmani, Shubham Saboo, and Sokratis Kartakis — provides the most comprehensive framework yet for understanding how AI is reshaping software development. It traces the spectrum from casual "vibe coding" to disciplined "agentic engineering," examines how the developer's role is shifting, and lays out what it takes to adopt these tools without sacrificing the discipline that production software demands.

From Syntax to Intent

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, and trusting intelligent systems to translate that intent into working software.

This shift didn't happen overnight. It began with autocomplete — simple token prediction in the editor. Then came inline code suggestions that could complete entire functions. Next, chat-based interfaces allowed developers to describe features in natural language and receive working implementations. Now, fully autonomous agents can clone repositories, plan multi-file changes, execute them in sandboxed environments, run tests, and submit pull requests — all without a human typing a single line of code.

The paper defines an AI agent as a system that perceives a goal, plans steps to reach it, takes actions through tools, observes the results, and iterates until the goal is met. Every agent, however simple or sophisticated, is built from five parts: the model (reasoning engine), tools (connection to the world), memory (state), orchestration (the loop), and deployment (production infrastructure).

The Spectrum: Vibe Coding to Agentic Engineering

In February 2025, Andrej Karpathy coined "vibe coding" to describe an approach where you "fully give in to the vibes, embrace exponentials, and forget that the code even exists." A developer describes what they want in natural language, accepts the AI's output, and when something breaks, copies the error message back into the prompt and asks the AI to fix it.

The term went viral because it captured something real — but it was applied so broadly it began to lose meaning. By early 2026, even Karpathy acknowledged the original framing was too narrow, introducing "agentic engineering" to describe the more disciplined end of the spectrum.

The paper frames them not as a binary but as endpoints on a spectrum. The key differentiator is not whether you use AI — it's how much structure, verification, and human judgment surrounds the AI's output.

The single biggest differentiator between the two ends is how outputs get verified. In vibe coding, verification is optional — the developer runs the code and checks if it seems right. In agentic engineering, two mechanisms work together: tests verify the deterministic parts of the system, while evaluations verify the parts that are not deterministic — did the agent take the right trajectory, choose the right tools, and produce output that meets the quality bar.

Without both tests and evals, the practice is always vibe coding, regardless of how sophisticated the prompts are.

Context Engineering: The Real Skill

As the field has matured, a key insight has emerged: the quality of AI-generated code depends less on the cleverness of your prompts and more on the quality of the context provided. This realization has given rise to context engineering — the practice of providing AI agents with rich, structured information about your codebase, architecture, conventions, and intent.

The paper identifies six primary types of context:

• Instructions — The agent's core role, goals, and operational boundaries
• Knowledge — Retrieved documents, architectural diagrams, domain-specific data
• Memory — Short-term session logs and long-term persistent state
• Examples — Few-shot behavioral demonstrations and codebase reference patterns
• Tools — Precise definitions of APIs, scripts, and external services the agent can invoke
• Guardrails — Hard constraints, formatting rules, and safety validations

The critical design decision is what belongs in static context (always loaded: system instructions, rule files, global memory) versus dynamic context (loaded on demand: skill instructions, tool results, RAG-fetched documents). Static context is expensive because every token is present in every interaction. Dynamic context is efficient because the agent pays the token cost only when the information is needed.

The most powerful pattern for managing dynamic context is Agent Skills: structured, portable packages of procedural knowledge that the agent loads only when the task calls for it. Rather than embedding every piece of specialized knowledge into the system prompt, skills allow the agent to remain a lightweight generalist that flexes into specialist roles on demand through progressive disclosure.

The New Software Development Life Cycle

AI compresses the traditional SDLC dramatically, but unevenly. Implementation that once took weeks can now be done in hours, while requirements, architecture, and verification remain stubbornly human-paced. The result is not a faster version of the old SDLC — it's a different workflow, where the boundaries between phases blur, iteration cycles shorten from weeks to minutes, and the developer's role shifts from primary implementor to system designer and quality arbiter.

The paper examines how AI transforms each phase:

Requirements and planning — Modern AI tools can generate user stories from product briefs, identify edge cases humans miss, produce API schemas from natural-language descriptions, and generate interactive prototypes from specification documents.

Design and architecture — AI agents can generate multiple architectural options, identify potential bottlenecks, and produce implementation plans. But the highest-impact human contribution remains here: defining the boundaries, making trade-off decisions, and ensuring the architecture aligns with organizational constraints.

Implementation — This is where the compression is most dramatic. AI agents can generate working code from specifications, handle multi-file changes, and iterate based on test results. But the "80% problem" persists: AI can rapidly generate approximately 80% of the code, while the remaining 20% — edge cases, error handling, integration points, and subtle correctness requirements — demands deep contextual knowledge that current models often lack.

Testing and QA — AI can generate test suites, identify coverage gaps, and even create evaluation harnesses for non-deterministic agent behavior. But the quality of tests depends on the quality of the specifications they're derived from.

Code review and deployment — AI-generated code requires the same or greater scrutiny than human-written code, with extra attention to hallucinated dependencies, inadequate error handling, and subtle correctness gaps that look right at a glance.

The Factory Model

The paper introduces the "factory model" as a framework for understanding agentic engineering. In this model, the software development system itself becomes the product. You build the system that builds software — a factory with defined inputs (specifications, context, constraints), processes (agent execution, testing, evaluation), and outputs (verified, deployable code).

The "harness" is what surrounds the model: the system prompts, skill libraries, MCP server connections, evaluation harnesses, and CI/CD pipelines that govern agent behavior. Teams that compound the most value from AI-assisted development are the ones that build their harness once and refine it many times.

The Developer's Evolving Role

The paper identifies two modes of developer engagement with AI agents:

The Conductor — Hands-on, real-time direction. The developer is actively guiding the agent, reviewing output as it's generated, and making immediate course corrections. This mode preserves the sense of understanding and control that many engineers value, but it can also become a bottleneck — if the developer is personally directing every keystroke, the throughput improvement from AI is limited.

The Orchestrator — Async, multi-agent delegation. The developer defines goals, assigns them to agents, and reviews results — but they're not watching code appear line by line. Agents may be working in the background, in parallel, on different parts of a codebase. This mode requires different skills: specification, decomposition, evaluation, and system design.

The developers who navigate this transition most effectively use AI for what it's good at — rapid implementation of well-specified tasks — while reserving their own attention for what AI struggles with: ambiguous requirements, architectural trade-offs, and correctness verification.

Coding Agents in Practice

The paper categorizes coding agents by where they show up in the developer's day:

In the editor — Inline completion, chat panels, whole-codebase awareness. GitHub Copilot, Cursor, Windsurf, JetBrains AI Assistant. This is where most people first meet AI in coding, and where the work stays in flow.

In the terminal — Agents launched from the command line, handed a goal in plain language, given full file system access, multi-file edits, and the ability to run tools and tests. Claude Code, Codex CLI, Open Code, Cline. This is where serious agentic engineering happens today.

In the background — Agents that take a task and run autonomously in cloud-hosted sandboxes, often for hours, producing a pull request as output. Google Jules, GitHub Copilot agent mode, Cursor's background agents. The developer hands off and reviews later.

The same developer often uses all three in a single day. The right starting point depends on the task, not on which category sits highest on some autonomy ladder.

The Economics of AI Development

The paper makes a crucial distinction between the economics of vibe coding versus agentic engineering:

Vibe coding has low CapEx but high OpEx. The barrier to entry is essentially zero — a standard monthly subscription and casual prompts. But the hidden costs compound: the token burn rate from repeated trial-and-error loops, the maintenance tax of unstructured AI-generated code, and the exponentially higher cost of fixing security flaws in production.

Agentic engineering has high CapEx but low OpEx. It requires deliberate upfront investment — designing API schemas, building deterministic test suites, and structuring the agent's context. But the marginal cost of shipping and maintaining a feature drops dramatically. The AI operates within a strictly governed factory, producing structurally sound, pre-tested output aligned with company standards.

In the token economy, context engineering is not just a technical skill — it's a financial strategy. Passing an entire 100,000-token repository into every prompt is financially unviable at scale. Effective context engineering ensures the model receives a dense, high-signal payload rather than a sprawling, noisy one.

Where to Start

The paper offers concrete advice for three audiences:

For individual developers: Set up an AGENTS.md for your project. Install skills for your coding agents. Pick one repetitive workflow and make it your first agent. Write tests and evals before generating code. Review every line that's going to ship. Maintain your developer skills — AI handles the routine so you can focus on the challenging, but that only works if your foundational skills stay sharp.

For engineering leaders: Make context engineering a first-class practice. Set the bar at the eval, not the demo. Re-shape code review for AI-generated code. Distinguish prototyping work from production work in team norms. Invest in harness components as shared team assets.

For organizations: Treat AI-assisted development as an engineering investment, not a productivity feature. Invest in the production substrate before scale. Adopt open standards for tools and inter-agent communication (MCP, A2A). Plan for hybrid teams of humans and agents. Reframe hiring and skill development around judgment, not just implementation.

Conclusion: Intent as the New Interface

Three principles from the paper stand out as durable:

Structure scales, vibes don't. Vibe coding is valid for exploration, prototyping, and personal projects. But for software that organizations depend on, the discipline of agentic engineering — specifications, tests, guardrails, and human oversight of architecture — is not optional.

AI amplifies your engineering culture. Organizations with strong testing practices, clear architectural standards, and healthy code review processes get dramatically more value from AI-assisted development than those without. AI is a force multiplier — and it multiplies both your strengths and your weaknesses.

The human role is evolving, not diminishing. The builders who understand architecture, can define precise specifications, evaluate output critically, and design effective systems of constraints and feedback loops are more valuable than ever. The skills that matter are shifting from implementation to judgment, from writing code to designing the systems that produce code.

As the paper concludes: "Generation is solved. Verification, judgment, and direction are the new craft."