The New Software Engineer

Specify precisely. Design the system. Verify rigorously.

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

Topics Covered

Part 1: The Bottleneck Moved
Part 2: The System Around the Model
Part 3: Specs Are the New Source Code
Part 4: Designing the System
Part 5: Trust Through Verification
Part 6: The New Software Engineer

Supporting concepts include: agent sandboxing and blast radius control, progressive context disclosure, AGENTS.md as a context delivery system, hybrid deterministic/agentic workflows, pre-completion middleware, false completion detection, Design by Contract, test-driven development, eval-driven development, and the economics of rigor.

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 follows a three-phase arc: foundation, principles, and synthesis.

Phase 1: Foundation (Parts 1 and 2)

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
The three control levers that make agent work reliable: bounding the agent's actions (isolation, permissions, blast radius), shaping the agent's view (context delivery, progressive disclosure), and shaping the agent's process (orchestration, mandatory checks, deterministic workflow steps). Concrete patterns from Stripe's devbox architecture, AGENTS.md, and LangChain's TerminalBench results.

Phase 2: Principles (Parts 3 through 5)

Part 3: Specs Are the New Source Code
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
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
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.

Phase 3: Synthesis (Part 6)

Part 6: The New Software Engineer
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