---

Program Overview

For decades, building software meant writing code. You designed the logic, typed it out, tested it, and shipped it. The value of a software engineer lived in the code they produced.

That era is ending. AI models can now generate code, debug it, run tests, and open pull requests. And the most influential engineering teams in the world have already made the shift. OpenAI shipped over a million lines of production code without a single line written by hand. Stripe merges 1,300 agent-generated pull requests every week. These teams didn't write more code. They built better systems that let agents write it for them.

But a capable model left on its own will write code that looks right but isn't. It will pass tests that don't test the right things. It will refactor code in ways that violate architectural rules it never knew about. It will get stuck in loops, retrying the same broken approach over and over.

The model is not the problem. The system around the model is.

This series teaches you the discipline that separates teams shipping with agents from teams struggling with them. It's built on three pillars: specifying what you want so precisely a machine can execute it, designing the system that maximizes the agent's chances of delivering it, and building the verification stack that confirms you got what you asked for.

The engineer who thrives in this era isn't the fastest typist. It's the one who can specify intent, design agent systems, and verify outcomes. That's the new software engineer.

---

What You'll Learn

This series covers the full shift from writing code to engineering the systems that write it. Across six videos, you'll learn:

• Why the engineering bottleneck has moved from model capability to system design
• How to build reliable agent systems using three control levers: isolation, context delivery, and orchestration
• How to write specifications precise enough for machines to execute faithfully
• The Intent Stack: the layered artifacts that replace code as the primary engineering output
• System design for agent workflows: task decomposition, deterministic vs. agentic steps, and progressive context disclosure
• The Verification Stack: layered systems that confirm agent output matches intent
• How to move from vibe coding to verified delegation using the 2x2 framework
• Eval-driven development: the flywheel that makes your system better at getting better
• What's precious in the new engineering role: judgment, specification precision, verification design, domain expertise, and taste

---

Key Frameworks Introduced

The Intent Stack: The layered artifacts expressing what you want: business goals, functional specs, technical constraints, interface contracts, acceptance criteria, and tests. The spec is the new source code.

The Verification Stack: The layered systems confirming you got it: type checking, linting, unit tests, integration tests, acceptance tests, evaluator models, and human review. Your verification depth determines your autonomy ceiling.

The 2x2 Grid: The landscape of agent-assisted development:

Most teams start at vibe coding. Careful teams move to guided execution. This series argues you should build toward verified delegation, the goal state where you specify the outcome and your verification stack confirms you got it.

---

Series Structure

The series contains six parts, moving from the shift in where engineering value lives, to the systems and principles that make agentic software reliable, to the role of the engineer in this new landscape.

Part 1: The Bottleneck Moved

Why the most influential engineers in the world have stopped writing code. What happens when raw models operate without systems around them. Proof points from OpenAI, Stripe, and Karpathy that the shift is already here. Introduces the core equation: Agent = Model + System.

Part 2: The System Around the Model

What makes agent work reliable is not the model alone, but the system around it. This part introduces three core levers: control over what the agent can touch and where it runs, context over what it sees and when, and checks that determine whether the work actually counts. Through examples like scoped environments, progressive disclosure, ambient context, and independent verification gates, it shows how reliability comes from harness engineering, not prompting alone.

Part 3: Specs Are the New Source Code

Release Date: April 21, 2026
Code is becoming what binaries already are: generated, disposable, regenerated from source. The spec is the new source. Introduces the Intent Stack as the primary engineering artifact. Traces the intellectual lineage from Design by Contract (1986) through TDD (1999) to the present. Shows why the economics finally favor rigor.

Part 4: Designing the System

Release Date: April 28, 2026
The gap between a clear spec and a verified outcome is where the engineering lives. Covers the three design levers: task decomposition (finding the seams), workflow structure (deterministic vs. agentic steps), and context timing (progressive disclosure). Shows how the same framework produces different system designs for prototypes, production features, and critical paths.

Part 5: Trust Through Verification

Release Date: May 05, 2026
Without verification, everything else in this series is speculation. Introduces the Verification Stack layer by layer and the 2x2 grid as the landscape of agent-assisted development. Covers eval-driven development, the flywheel where every failure becomes a permanent system improvement. Establishes the governing rule: your verification depth determines your autonomy ceiling.

Part 6: The New Software Engineer

Release Date: May 12, 2026
Pulls together all three pillars into a role. Addresses the identity question: if the agent writes the code, what's left for you? Introduces Martin Fowler's three positions (out of the loop, in the loop, on the loop) and argues for the third. Names what's precious: judgment, specification precision, system design, verification design, domain expertise, and taste. Traces five decades of ideas, from information hiding (1972) to TDD (1999), converging in this moment.

---

Who This Series Is For

This series is for engineers and technical leaders navigating the shift from writing code to designing the systems that write it.

Ideal for:

• Software engineers working with or evaluating AI coding agents
• Engineering managers and tech leads building agent-assisted workflows
• Senior developers who want to understand what the role becomes, not just what the tools do
• Technical architects designing reliable agent systems for their teams
• Anyone who has used AI coding tools and wondered: "How do I make this actually reliable?"

No prior experience with agent frameworks is required. The series focuses on principles and system design, not specific tools.

What You'll Take Away

After watching the full series, you'll have:

• A clear mental model for why raw agents fail and what makes agent systems reliable
• The vocabulary and frameworks to design agent workflows: the Intent Stack, the Verification Stack, the 2x2 grid
• Practical patterns for task decomposition, context delivery, and verification design
• A principled approach to deciding how much autonomy to grant and when
• Confidence that the engineering role isn't disappearing, it's being elevated to what it always should have been

---