The New SDLC: From vibe coding to Agentic Engineering

Key takeaways

1. 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.
2. Framing data (2026). 85% of professional developers regularly use coding agents, 51% daily, 41% of new code is AI-generated.
3. 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".
4. The agent = loop. perceive goal → plan → act (tools) → observe → iterate (self-correction). Built from 5 parts (cf. whitepaper Introduction to Agents, Nov. 2025): model, tools, memory, orchestration, deployment. "The loop is the beating heart of every agent."
5. Vibe coding. term coined by Karpathy (Feb. 2025, "fully give in to the vibes"); applied so broadly it lost its meaning → early 2026 Karpathy introduces agentic engineering for the disciplined end of the spectrum.
6. 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."
7. Verification = the real differentiator. Tests verify the deterministic (input→output); Evals verify the non-deterministic (right trajectory? right tools? response at the right quality level?), via labeled datasets, scoring rubrics, LM judges. "Without both, the practice is always vibe coding, regardless of how sophisticated the prompts are."
8. 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) vs dynamic (loaded on demand: skills, RAG, tool results — efficient).
9. Agent Skills. = the most powerful pattern for dynamic context (progressive disclosure: metadata at startup, instructions on match, references as needed). Solves 4 problems: context rot, lack of procedural memory, multi-agent operational overhead, cross-tool portability.
10. The new SDLC. AI compresses the cycle unevenly — implementation goes 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.
11. By phase. Requirements (collapses requirements→prototype); Design/architecture = the most stubbornly human phase (trade-off arbitration); Implementation (gains of 25-39%, but 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 (technical debt "too risky to touch" becomes refactorable).
12. 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 the quality control, not each individual piece.
13. 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 checkpoints), observability. "This surrounding machinery is known as the Harness."
14. Evidence of the harness effect. on Terminal Bench 2.0, a team took 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."
15. 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."
16. The 80% problem. AI quickly generates ~80% of the code; the remaining 20% (edge cases, error handling, integration, subtle fixes) require deep contextual knowledge. AI errors have shifted from syntax mistakes to conceptual failures (the code "looks right" and passes basic tests).
17. Agents in practice — 3 places. 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.
18. 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 = 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-10x more per feature.
19. Conclusion — 3 durable principles. (1) "Structure scales, vibes don't"; (2) "AI amplifies your engineering culture" (a multiplier of both strengths AND weaknesses); (3) "The human role is evolving, not diminishing". Closing line: "Generation is solved. Verification, judgment, and direction are the new craft."
20. 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).