prd-please
prd-please is a methodology for writing product requirements clearly enough that an AI coding assistant can build the thing you actually had in mind.
What it does
AI coding assistants are capable, but they need to be told clearly what to build. Ask for "an app" and you will get an app, just not the one you had in mind. The gap is not the assistant's intelligence but the specification, the document that says what you are building and why.
That document is a PRD, a product requirements document, and prd-please is a structured way to write one. It calls the result a Strategic PRD, and it does three jobs:
- Distillation: it turns scattered context, what is in your head, in chat threads, in meeting notes, into one clear, structured source of truth.
- Operationalization: it breaks that source of truth into concrete tasks, so building can start in hours rather than days.
- Learning: it feeds what you discover while building back into the source of truth, so the same mistake does not get made twice.
How it works
prd-please is a set of step-by-step workflows, called skills, that you move through in sequence:
- Discovery: a structured interview that surfaces what you know, what you are assuming, and what you have not figured out yet, before a word of the PRD is written.
- Authoring: turning that into the Strategic PRD itself.
- Taskmaster: breaking the PRD into a task list a builder, whether a person or an AI assistant, can pick up.
- Validation: checking what got built against what the PRD asked for.
- Learning: capturing what the build taught you and proposing updates to the PRD.
It is built to make you better at specifying products, not just faster at producing documents. Every step explains why it is asking what it asks, and it leaves behind a short companion note on why the output reads the way it does, so you could do it yourself next time.
When the builder is an AI
prd-please now also covers the build itself. When the builder is an AI assistant rather than a person, the framework runs the work as a loop: implement a small batch of tasks, check it, capture what the batch taught you, fold that back into the PRD, and start the next batch. This is the same loop I run on real client builds, written down and made part of the open framework.
A few rules make the loop safe to leave running:
- The agent that checks the work is separate from the agent that did it, and it is deliberately skeptical. It runs the tests itself rather than believing a report that says they pass.
- An agent that hits something it cannot finish has to say so, visibly. Quietly faking success is treated as the worst outcome there is, worse than failing.
- Progress lives in files, not in the assistant's memory, so the build picks up exactly where it left off, even across sessions.
- Questions that need a human are collected into one ranked list instead of arriving as a stream of interruptions.
You can ignore all of this and use the PRD methodology on its own. The loop is there for when the building starts.
When an engagement goes all the way into building software, prd-please also hands off to two more open tools: Archgate, which keeps key architecture decisions enforced as the build proceeds, and Aldente, a phased workflow for building software products. These are optional too.
Who it's for
- Founders turning an idea into something a developer or an AI assistant can build
- Small teams who keep getting "an app, just not the one we needed"
- Anyone who wants the thinking written down and agreed on before the building starts
Using it without writing code
You do not need to be a developer to use prd-please, and you do not need to be comfortable with GitHub. The framework is a set of plain-language instructions that an AI assistant reads and works from. Your part is the conversation.
The quickest way in is the "Open in Claude" button on this page. It hands Claude a short brief on prd-please and leaves room for you to describe your own situation, so you can talk through the fit before committing to anything.
To run the framework itself, you open the repository with Claude Code, Anthropic's assistant that works directly with files, and tell it what you need in ordinary sentences, like "write a PRD for our new onboarding flow." It handles setup the first time and walks you through the rest. If any of that feels unfamiliar, it is a good thing to bring to a first conversation.
See it on GitHub
The full methodology, its step-by-step skills, and a worked example are all in the open repository: