AI Daily Briefing — May 21, 2026
Special Episode: Structured Prompt-Driven Development

Welcome to a special deep-dive episode of the AI Daily Briefing. Today we're unpacking a major new article from Martin Fowler's site by the Thoughtworks Global IT Services team — Structured Prompt-Driven Development, or SPDD for short.

The core problem SPDD addresses is one you've probably felt yourself. AI coding assistants make individual developers dramatically faster at drafting, modifying, and refactoring code. But delivery speed is rarely limited by typing. When you zoom out to the full delivery lifecycle — requirements through release — new friction appears everywhere. Ambiguous requirements become code faster than ever, and misunderstandings scale with them. Reviews get flooded with more change. Inconsistency creeps in because "generated" doesn't mean "aligned." Production risk becomes harder to reason about when the volume of change rises through the roof.

The Thoughtworks team puts it perfectly: it's like buying a Ferrari and driving it on muddy roads. The engine is powerful, but your arrival time is determined by road conditions, not horsepower.

SPDD is their answer. It's an engineering method that treats prompts as first-class delivery artifacts — version controlled, reviewed, reused, and improved over time, just like code. The method has two core pieces: the REASONS Canvas and the SPDD workflow.

The REASONS Canvas is a seven-part structure that forces clarity before a single line of code is generated. R stands for Requirements — what problem are we solving and what's the definition of done. E is Entities — the domain model and relationships. A is Approach — the strategy. S is Structure — where the change fits in the system. O is Operations — concrete, testable implementation steps. N is Norms — cross-cutting engineering standards like naming and observability. And the final S is Safeguards — non-negotiable boundaries like invariants, performance limits, and security rules.

The canvas moves uncertainty to the left. Instead of discovering misalignment during code review, you catch it at the prompt stage, where it's cheap to fix. Because the structured prompt captures the full specification, reviewers reason about a single artifact instead of scattered chat logs and partial diffs. And as domain knowledge accumulates in each prompt, it compounds across iterations.

The SPDD workflow enforces a simple but powerful rule: when reality diverges, fix the prompt first, then update the code. This creates a closed loop — business input flows to abstraction, abstraction to execution, execution to validation, and validation feeds back to the prompt. Code and intent stay in sync.

The article includes a full walkthrough using an open-source CLI tool called openspdd, which provides seven slash commands that implement the workflow. You start with spdd-story to break requirements into INVEST-compliant user stories. Then spdd-analysis scans the codebase for relevant domain concepts and produces a strategic analysis. spdd-reasons-canvas generates the full executable blueprint. spdd-generate reads that canvas and produces code task by task. spdd-api-test generates cURL-based test scripts. spdd-prompt-update handles requirement changes by updating the prompt before the code. And spdd-sync pushes code-side changes like refactoring back into the prompt so nothing drifts out of date.

The walkthrough enhances a billing engine for LLM token usage, taking it from static pricing to multi-plan, model-aware billing with Strategy Pattern routing. What's striking is how the process inverts the typical AI workflow. Instead of the developer prompting, reading output, re-prompting, and patching — they spend their energy on reviewing and refining the prompt itself. The AI does the code generation within a governed boundary.

The key insight is this: reviews move away from "spot the bug" toward "check the intent." Over time, successful patterns accumulate into a reusable prompt library — what Thoughtworks calls AI-First Software Delivery, or AIFSD. If you've heard of spec-driven development, SPDD is the AI-native evolution of that idea, with prompts as the governed, reusable, versioned team assets.

The article positions SPDD alongside Birgitta Böckeler's taxonomy of spec-anchored approaches. It's not about generating more code faster. It's about making AI-generated changes governable, reviewable, and reusable — so teams get faster and safer at the same time.

That's the deep dive for May twenty-first. The full article is up on martinfowler.com — link in the show notes. I'm Bob, back with your regular news briefing tomorrow.