How to Implement Structured Prompt-Driven Development (SPDD) in Your Team

Introduction

LLM programming assistants have transformed individual developer workflows, but their power multiplies when used across a team. Thoughtworks' internal IT organization has pioneered a method called Structured Prompt-Driven Development (SPDD) to harness this collective potential. By treating prompts as first-class artifacts—versioned, reviewed, and aligned with business needs—SPDD turns ad-hoc LLM usage into a repeatable, team-wide practice. This guide walks you through setting up SPDD from scratch, based on a simple example shared by Wei Zhang and Jessie Jie Xia on GitHub. You'll learn the three essential skills: alignment, abstraction-first, and iterative review. By the end, you'll have a workflow that keeps your team's LLM interactions consistent, traceable, and business-aligned.

What You Need

• Access to an LLM programming assistant (e.g., GPT-4, Claude, or GitHub Copilot code chat)
• A version control system (Git is recommended)
• A shared code repository for your project
• The example SPDD repository by Wei Zhang and Jessie Jie Xia (link in resources)
• A small team (2–5 developers) willing to experiment
• Basic familiarity with prompt engineering and code review

Step-by-Step Guide

Step 1: Define Business Alignment Before Writing Prompts

Before you type a single prompt, clarify what business problem the LLM should solve. Gather requirements from stakeholders and translate them into explicit user stories or acceptance criteria. This alignment step ensures that every prompt you craft directly serves a business need, not just a technical itch. Write down the goal in plain language—for example, “Generate a function that validates email addresses according to our company’s format rules.” Share this with your team to avoid drift.

Step 2: Adopt an Abstraction-First Mindset

Instead of asking the LLM for a complete solution right away, break the problem into abstract components. Think of these as “prompt modules” that handle subtasks. For the email validator example, you might split it into: (a) parse the input, (b) check allowed characters, (c) verify domain pattern. Write one prompt per abstraction layer. This abstraction-first approach makes prompts reusable and easier to debug—each prompt focuses on a single concern, much like a function in clean code.

Step 3: Write and Store Prompts as First-Class Artifacts

Create a dedicated directory in your repository (e.g., prompts/) to store each prompt you write. Use descriptive filenames like validate-email-parse.prompt. Each file contains the prompt text, expected input format, and sample output. Save these alongside the generated code. This practice turns prompts into version-controlled documentation—you can track changes, revert, and understand why the LLM produced certain outputs.

Step 4: Execute Prompts Iteratively with Version Control

Run each prompt against your LLM assistant, capture the output, and commit both the prompt file and the resulting code to your repository. Use a commit message that references the prompt file and the business requirement (e.g., “Added email parser prompt implement regex validation”). Now you have a iterative review loop: after each commit, review the output against the business need. If the LLM’s code has errors or misses requirements, update the prompt (not the code directly) and re-run. This keeps the prompt as the single source of truth.

Step 5: Conduct Collaborative Prompt Reviews

Treat prompt files like code—conduct pull requests and code reviews for prompts. Have another developer examine the prompt for clarity, completeness, and alignment with business needs. They might ask: “Does this prompt handle edge cases?” or “Is the abstraction level appropriate?” This team review instills the three skills: alignment (is it on target?), abstraction-first (is it decomposed well?), and iterative improvement (can we refine?). Merge only when reviewers approve.

Step 6: Maintain a Prompt Library

Over time, your prompts/ directory becomes a library. Curate it: group related prompts into subdirectories, write a README explaining each module’s purpose, and link prompts to specific business needs. When a new task arises, search this library before writing fresh prompts. This reuses proven abstractions and speeds up development. For example, if a new feature needs validation, you can reuse the validate-email-parse.prompt and adjust it slightly.

Step 7: Measure and Refine Your SPDD Workflow

After a few sprints, collect metrics: how often did prompt changes fix bugs? Did alignment improve? How many prompt reuse instances occurred? Use these insights to refine your process—maybe you need stricter alignment checklists or more granular abstractions. Continuously improve the prompt library and review practices. Remember, SPDD is a living methodology, not a one-time setup.

Tips for Success

• Start small: Choose one simple, well-understood business function for your first SPDD trial—avoid complex workflows initially.
• Pair on prompts: Like pair programming, pair on prompt writing to catch misalignments early.
• Use a prompt template: Standardize prompts with sections like Role, Task, Input/Output format, Constraints to improve consistency.
• Version your LLM too: Note which model and version you used (e.g., GPT-4-turbo-2024-04-09) in the prompt file header – model behavior changes can break prompts.
• Monitor for “prompt decay”: If the same prompt starts giving lower-quality outputs, revisit alignment and abstraction – business needs evolve.
• Celebrate reuse: When a prompt is reused in multiple places, highlight it in team demos to encourage the practice.
• Document failures: Keep a log of prompts that led to poor results and why – this becomes a valuable learning resource.