Introduction

Large language model (LLM) programming assistants have proven valuable for individual developers, boosting productivity and reducing boilerplate. However, the real challenge lies in leveraging these tools effectively within a team—ensuring consistency, alignment with business goals, and maintainable workflows. Thoughtworks' internal IT organization has pioneered a method to address this: Structured Prompt-Driven Development (SPDD). Developed by Wei Zhang and Jessie Jie Xia, SPDD treats prompts as first-class artifacts, stored alongside code in version control, and used to synchronize development with business needs. This article explores the SPDD workflow, its core principles, and the three essential skills developers need to master for success.

The Origins of SPDD

Wei Zhang and Jessie Jie Xia, engineers at Thoughtworks, designed SPDD after observing that prompt-based coding assistants often led to inconsistent results across team members. Without a shared framework, each developer might craft prompts differently, leading to divergent code styles, incomplete features, and difficulty in debugging or iterating. The duo published a detailed example of the SPDD workflow on GitHub, demonstrating how a simple request—such as building a REST API endpoint—can be decomposed into structured prompts that are stored, versioned, and reused. By institutionalizing prompt design, the team ensures that every developer follows a repeatable process, reducing errors and improving collaboration. SPDD is not just about writing better prompts; it's about embedding prompt engineering into the software development lifecycle.

Core Principles of SPDD

Prompts as First-Class Artifacts

In traditional software development, code is the primary artifact, and prompts are often ephemeral—typed into a chat interface and discarded. SPDD changes that by requiring prompts to be created, maintained, and versioned just like source code. Each prompt is documented with its purpose, expected outputs, and dependencies. This allows teams to track changes, roll back if needed, and reuse proven prompts across projects. In practice, this means storing prompt files (e.g., .prompt or .md) in the same repository, alongside tests and configuration files. As a result, the entire team can see how the AI was instructed to generate a particular piece of code, fostering transparency and reproducibility.

Alignment with Business Needs

SPDD emphasizes that prompts must be tightly coupled to business requirements. Instead of asking the LLM to "write a function to calculate tax," the prompt includes the specific tax rules, edge cases, and acceptance criteria defined by the product owner. This alignment reduces ambiguity and ensures that the generated code directly addresses stakeholder needs. The team can even create prompt templates that mirror user stories, complete with acceptance criteria and context from the domain. By keeping prompts in version control, any changes to business requirements are reflected in the prompt history, making audit trails straightforward.

Iterative Refinement

Unlike a one-shot approach, SPDD treats prompt creation as an iterative process. Developers start with a high-level prompt, review the output, and refine the prompt based on feedback from code reviews, tests, and stakeholders. This cycle mirrors agile development practices and encourages continuous improvement. The iterative review step is critical—it ensures that the AI's output doesn't introduce subtle bugs or misinterpretations. Over time, teams build a library of refined prompts that become a valuable organizational asset.

Three Key Skills for Developers

Wei Zhang and Jessie Jie Xia identified three skills that developers need to be effective with SPDD:

Alignment

Developers must learn to align prompts with business context and technical constraints. This means understanding the product's goals, the end users' needs, and the system's architecture before writing a prompt. Alignment also involves breaking down a complex task into smaller, focused prompts that each address a single concern—much like decomposing a feature into user stories. Without alignment, the AI might generate code that works syntactically but fails to solve the business problem.

Abstraction-First Thinking

Rather than diving into implementation details, SPDD encourages developers to start with an abstract description of what the code should achieve. For example, instead of prompting for a specific loop or data structure, a developer might write: "Design a service that processes orders, handling validation, payment, and notification in sequence." This high-level prompt can then be expanded into sub-prompts for each step. Abstraction-first thinking helps the LLM generate more robust and maintainable code, as it can apply its training to design patterns rather than narrowing the solution prematurely.

Iterative Review

The third skill is the ability to critically review AI-generated output and refine prompts iteratively. Developers must verify that the code meets requirements, follows coding standards, and integrates well with existing systems. They should also be comfortable tweaking prompts based on review feedback—whether it's adding more context, clarifying edge cases, or adjusting the tone of comments. This skill turns the development process into a feedback loop, where both the human and the AI learn from each iteration.

Benefits for Teams

SPDD offers several advantages over ad-hoc prompt usage. It standardizes the way teams interact with LLMs, reducing variance and improving code quality. Prompts become shareable assets that can be reused across projects, accelerating onboarding for new team members. Version control integration ensures that prompt changes are linked to feature changes, simplifying debugging and audits. Additionally, by making prompts explicit, SPDD fosters a culture of documentation and transparency. Teams using SPDD have reported fewer misunderstandings about feature requirements and less time spent correcting auto-generated code that deviated from expectations.

Getting Started with SPDD

To adopt SPDD, teams can start small—pick a single feature or user story and apply the workflow. Create a prompt file, store it in the repository, and go through the iteration cycle: write prompt, generate code, review, refine. Over time, build a collection of proven prompts that can be referenced. Tools like GitHub Actions can even automate prompt testing by running the generated code through a suite of unit tests. The key is to treat prompts as living documents that evolve alongside the codebase.

Conclusion

Structured Prompt-Driven Development represents a maturation of LLM-assisted coding. By elevating prompts to first-class artifacts, aligning them with business needs, and fostering skills in alignment, abstraction, and iterative review, teams can harness AI more effectively. While individual developer productivity gains are impressive, the real value emerges when entire teams share a common, structured approach. As Wei Zhang and Jessie Jie Xia's example on GitHub illustrates, SPDD is practical and scalable—a template for how organizations can turn AI assistance into a reliable, team-friendly engineering practice.