Software Development Life Cycle (SDLC)

Sep 22, 2026 · 1:01:34

Full Course: Spec-Driven Development with Coding Agents

Spec-Driven Development (SDD) is presented as the disciplined, professional workflow for building complex applications using coding agents, moving beyond 'vibe coding.' SDD mandates that the developer focuses on writing a detailed specification (the 'what' and 'why') before the agent implements the code (the 'how'). The process involves establishing a project Constitution, defining feature specs, and following a structured loop: Plan $ ightarrow$ Implement $ ightarrow$ Validate $ ightarrow$ Replanning. This approach minimizes context decay, improves intent fidelity, and keeps the human developer in the role of the senior architect and supervisor.

Key takeaways

Three Main Benefits of SDD
SDD allows control of large code changes with small spec changes (e.g., changing from SQLite to MongoDB). It eliminates context decay between sessions, preserving non-negotiable context. Finally, it improves intent fidelity by forcing the definition of problem, success criteria, and constraints.
The SDD Workflow Loop 5:20
The process is iterative: 1) Define the Project Constitution (Mission, Tech Stack, Roadmap); 2) Plan the Feature; 3) Implement the Feature; 4) Validate the Result; 5) Replanning (updating the Constitution/Roadmap). This loop is crucial for managing versioning and reducing cognitive debt.
Agent Standards and Automation 20:00
The workflow can be automated using 'Skills' (a package of instructions/resources) and benefits from industry standards like the Agent Client Protocol (ACP) and Model Context Protocol (MCP), allowing developers to switch between different coding agents (e.g., Claude Code, Codeex) while maintaining the SDD workflow.

Watch on YouTube Full article

Sep 21, 2026 · 8:26

Goodbye Tokenmaxxing: From AI Usage to Agentic AI Outcomes

The industry is shifting AI success metrics from simple usage volume (token consumption) to measurable business outcomes, a concept termed Valuemaxxing. Traditional approaches like 'tokenmaxxing' (maximizing usage) and 'token minimization' (restricting usage) fail because they treat token count as a proxy for value. As AI evolves into complex Agentic AI systems that plan workflows and coordinate across multiple systems, true value is determined by system effectiveness, model orchestration, and the measurable impact on the Software Development Life Cycle (SDLC), such as reduced rework or resolved vulnerabilities.

Key takeaways

The Failure of Usage Metrics
Relying on metrics like token consumption or adoption rates (tokenmaxxing) is insufficient because these metrics only measure activity, not operational outcomes. Usage dashboards can be gamed, and cost savings achieved through token minimization can lead to critical information loss (e.g., stripping architectural context), resulting in higher debugging and rework costs elsewhere.
The Shift to Valuemaxxing 4:00
Valuemaxxing shifts the focus from 'how many tokens were used' to 'what was achieved.' Key outcome metrics include the number of deployments completed, developer time saved, rework avoided, and vulnerabilities resolved. Token consumption should be rooted in higher quality software and successful outcomes.
System Effectiveness over Model Selection 5:30
As models become infrastructure, the differentiator is shifting from access to great models to the system built around them. This emphasizes model orchestration, context management, and workflow governance. IDC predicts that by 2028, 70% of large-scale AI deployments will utilize multiple models.

Watch on YouTube Full article

Aug 21, 2026 · 18:26

Agentic SDLC at Uber — Uday Kiran Medisetty & Adam Huda, Uber

Uber has implemented a comprehensive 'Software Factory' powered by agentic AI to revolutionize its SDLC. Key infrastructure investments include a centralized Model Gateway for security and latency control, an MCP Gateway for token optimization, and a Context Graph that unifies knowledge across disparate systems. These building blocks enable autonomous agents (like Minion) to accelerate development from idea generation (via Cortana) through drafting PRs, validating changes in inner loops (e.g., comparing simulator screenshots against Figma specs), and managing maintenance tasks.

Key takeaways

Agentic Adoption Metrics
Over the last year, agentic AI led to more than 70% of Uber's Pull Requests (PRs) originating from local or cloud agents, resulting in double the lines of code per engineer year-over-year.
Model Gateway Performance 2:06
The Model Gateway handles all internal model calls through a single endpoint, ensuring PII redaction for over 20 types and running five specialized safety models under a strict 100 millisecond guardrail budget. It processes over 100 million requests daily across 800+ projects.
Token Optimization 5:51
The MCP Gateway, combined with projecting MCPS into CLI patterns and using Omni MCP, cut fleetwide token usage by more than 40%.

Watch on YouTube Full article

Aug 20, 2026 · 18:54

The Last Human Code Review: Building Trust in AI-Generated Code — Itamar Friedman, Qodo

The bottleneck in modern software development is shifting from writing code to managing governance and context within the Software Development Life Cycle (SDLC). The speaker argues that AI models are no longer the primary constraint; instead, the critical challenge is codifying 'tribal knowledge'—the undocumented best practices, architectural contracts, and historical failure data held by senior developers. Future code review must transition from line-by-line diff checking to reviewing a comprehensive software graph that tracks inter-service dependencies and potential contract breaks across multiple concurrent Pull Requests (PRs).

Key takeaways

The Bottleneck Shift
The primary bottleneck is no longer writing code, but rather the governance layer within the SDLC. Organizations must address how to automate or enhance code review processes that validate architectural standards and business intent.
Two Competing Philosophies 5:38
Engineering leaders are split into two camps: those who insist every line of code requires human trust/review, and those who prioritize velocity by shipping bugs quickly and fixing them post-deployment. The chosen philosophy dictates the necessary tooling and governance strategy.
Context is the Constraint 8:39
The limitation is not model reasoning ability; it is the scattered nature of context—which resides across competing instruction files, internal team standards, and undocumented knowledge held in developers' heads or Slack threads. Codifying this context is paramount.

Watch on YouTube Full article

Aug 10, 2026 · 37:15

Engineers… Your Software Factory NEEDS Agent Sandboxes to SCALE (exe.dev)

The video argues that traditional methods of running AI agents—such as allocating a small corner of a local machine or relying solely on containers/CI/CD—create bottlenecks. To achieve true scale and autonomy in an 'AI developer workflow' (ADW), the entire software factory must be moved into dedicated, isolated agent sandboxes (e.g., using exe.dev). This architecture enables complex workflows like running 'Best of N' comparisons across multiple model configurations while maintaining zero blast radius via disposable keys.

Key takeaways

The Bottleneck Problem
If an engineer is 'in the loop,' they are the bottleneck. True scaling requires moving beyond local compute limitations by giving every agent its own isolated computer, achieving isolation, scale, and autonomy.
Three-Tier Architecture for Scale 23:25
The recommended architecture involves an Out-loop orchestrator (on the engineer's machine), an In-sandbox orchestrator (on each VM), and the core Software Factory/ADW agents running inside the sandbox. This allows the top-level agent to kick off work and then go quiet, only requiring human intervention at planning and reviewing stages.
Best of N Pattern 17:05
Sandboxes enable running 'Best of N' patterns by simultaneously executing the same prompt/workflow across multiple agent configurations (e.g., Default, Frontier, Deepest, Open Weights), allowing for comparison and selection of the optimal outcome.
Security and Isolation 27:50
Sandboxes provide critical security by ensuring a 'bounded blast radius.' Agents use ephemeral resources, such as OpenRouter provisioning keys with hard spend caps, which are revoked upon teardown, preventing unauthorized access to production systems (e.g., AWS).

Watch on YouTube Full article

Aug 3, 2026 · 29:53

My Super Simple Software Factory (For Agentic Engineers)

The video introduces the concept of a 'Software Factory'—an advanced system for agentic engineering that moves beyond relying solely on autonomous agents. The core thesis is that combining **Agents + Code** provides significantly more leverage and reliability than agents alone. This factory automates the entire Software Development Life Cycle (SDLC) by integrating deterministic code checks, ensuring repeatability, observability, and scalability across complex AI developer workflows.

Key takeaways

Agents Plus Code is Superior
The most significant advancement in agentic engineering is the combination of agents with explicit, deterministic code. This structure ensures reliability, cost control, and verifiable output, mitigating risks associated with pure AI orchestration.
Three Core Design Principles 2:00
The Super Simple Software Factory is built on three non-negotiable principles: **Observable** (full visibility into every phase, prompt, and cost breakdown); **Customizable** (using a single YAML config to control the core four elements: context, model, prompt, tool); and **Reusable** (deployable across any codebase via an `/install` command).
Scaling Compute for Impact 3:50
The system is designed to scale compute power by orchestrating complex, multi-step workflows (e.g., Plan $ ightarrow$ Build $ ightarrow$ Test $ ightarrow$ Review) that operate without constant human intervention.

Watch on YouTube Full article

Jul 30, 2026 · 13:42

Your Finance Agent's Bottleneck Is You — Ramana Siddanth Emani, Auditoria AI

The primary bottleneck in developing production AI agents, especially for regulated fields like finance, is not model capability or hardware, but the developer's manual workflow. The talk outlines how advanced agent harnesses can automate and multiply human output by implementing primitives such as sub-agents, skills, goals, and loops. By orchestrating these agents across parallel worktrees (e.g., handling multiple Jira tickets simultaneously), developers can drastically reduce time spent on repetitive tasks like testing, building, and deployment, shifting the human role from executor to final verifier.

Key takeaways

The Developer Loop is the Bottleneck
Shipping production agents fails due to developer velocity limitations. The solution lies in automating the internal developer loop rather than waiting for model or hardware upgrades (0:00, 2:37).
Parallel Task Execution via Sub-Agents 7:02
Sub-agents allow for parallel processing using isolated 'worktrees'—virtual folders where agents write and execute code independently. This enables handling multiple tasks (e.g., QA bug tickets) simultaneously, far exceeding human capacity (4:22).
Minimal UX for Orchestration 8:38
Effective agent use requires minimal User Experience (UX), consolidating all project dashboards, logs, Jira tickets, and GitHub PRs into a single pane of glass widget to reduce context switching and manual orchestration effort (5:18).
Achieving Autonomy with Goals and Dreaming
Future agent development involves combining 'goals' (setting a desired outcome) with automated loops. Furthermore, allowing agents to 'dream' by collecting customer usage patterns can drive self-improvement and feature upgrades autonomously (11:35).

Watch on YouTube Full article

Jul 28, 2026 · 33:39

AI Agents for Performance: Ship Faster, Pay Less — Rajat Shah, Netflix

This talk outlines how Netflix leveraged AI agents to automate performance engineering, addressing the bottleneck of manually identifying and fixing inefficient code patterns in production services. The process involves feeding profiling data (call stacks, CPU usage) into an LLM agent, which identifies suboptimal algorithms (e.g., quadratic-time patterns). The agent then proposes a fix, validates it against a canary deployment using real production traffic, and can even scale the fix across multiple services by identifying common anti-patterns in a centralized catalog. This shifts performance optimization from a reactive, manual effort to a proactive, automated part of the SDLC.

Key takeaways

The Performance Bottleneck 4:00
Traditional performance engineering is highly manual and time-consuming (taking minutes just to identify hot paths), making it difficult to scale across large codebases. This bottleneck increases as coding agents write code faster, potentially introducing inefficiencies.
AI Agent Workflow for Optimization 12:17
An LLM agent can automate the entire loop: reading profiling data (call stack/CPU time), identifying anti-patterns (like O(N²) loops), locating the code path in the Git repo, proposing a fix, and validating it via canary deployment.
Scaling Fixes with Pattern Catalogs 21:20
Instead of fixing one instance, agents can search across multiple services using a centralized 'Pattern/Anti-pattern Catalog' (stored in a Git repo) to find and propose fixes for the same bad pattern repeatedly implemented elsewhere.
Shifting Left: Proactive Performance 26:40
The goal is to move performance improvement left in the SDLC. The catalog can be used proactively—at code review or even during code authoring—to suggest optimal patterns before suboptimal code reaches production.

Watch on YouTube Full article

Jul 20, 2026 · 26:22

Engineers... STOP Picking GPT-5.6 Sol OR Claude Fable 5… FUSE THEM

The video argues that in agentic engineering, the optimal approach is not to choose a single 'winner' model (e.g., GPT 5.6 Sol vs. Claude Fable 5), but rather to implement Model Fusion. This involves building custom agent harnesses that coordinate multiple state-of-the-art models working together. The process utilizes specialized commands—`/opinion` for diverse perspectives, `/fusion` for consolidating results, and `/auto validate` for intelligent on-the-fly review—to significantly outperform single-agent workflows.

Key takeaways

Model Fusion: AND, Not OR
The most powerful approach is combining the compute and intelligence of multiple models rather than selecting a single winner. This pattern combines concepts previously known as architect editor, prompt chaining, and agent chaining.
Three Core Commands for Orchestration 2:00
A custom fusion harness uses three commands: `/opinion` (to gather multiple perspectives), `/fusion` (to combine and consolidate results), and `/auto validate` (for intelligent on-the-fly validation, addressing the review constraint of agentic engineering).
Value of Fusion vs. Single Agent 5:45
Fusion allows agents to identify consensus, divergence, and discarded information, providing a comprehensive view that is critical for high-stakes strategic decisions.

Watch on YouTube Full article