Phase 3: Build

What: Implement the thin slice.

Thinking mode: Engineering thinking. Making it real. This is where AI agents shine as execution partners. A solo builder might hand the slice spec to an agent and pair with it directly. On a team, whoever has the best context on the codebase drives. Sometimes that's an engineer, sometimes it's a PM who's been living in the code, sometimes it's an agent with the right context window.

Inputs: The slice specification, codebase, test suite.

Output: Working code (not production-ready, but working).

The goal is to preserve context and catch drift early, without blocking execution. Building is not the "easy part" that anyone can do. It requires real judgment about architecture, trade-offs, and quality. What's changed is that AI amplifies that judgment, making it possible to go from spec to working code in hours instead of days.

Spec-Driven Development lives here

If you're familiar with Spec-Driven Development (SDD), this is where it fits. SDD is the practice of writing a tight, detailed spec and handing it to an agent to build. The spec is the interface between human intent and agent execution.

LDD and SDD are complementary, not competing. LDD wraps around SDD:

• Frame answers what do we believe and why does it matter?
• Slice answers what are we exposing to users and what does the spec look like?
• Build (SDD) answers how do we get the agent to build it well?
• Validate answers were we right?
• Decide answers what do we do next?

SDD on its own builds exactly what the spec says. LDD makes sure the spec is worth building in the first place, and that what gets built actually gets validated. Without LDD, SDD can produce perfectly executed code that solves the wrong problem. Without SDD, LDD's Build phase lacks the discipline to get clean, reliable output from agents.

Think of it this way: LDD is the learning system. SDD is the execution engine inside it.