Introduction
Today we’re going to tackle a very specific problem: how to get AI to help you write a great PRD (Product Requirements Document)?
Imagine these scenarios:
-
Scenario 1: You have a brilliant idea and can’t wait to have AI build it for you. But without professional product manager training, after countless rounds of conversation with AI and spending hours plus significant token costs, the final result still isn’t what you expected.
-
Scenario 2: You’re a newcomer to the software product manager field. Perhaps you gave up weekend plans with friends to work overtime and wrote a PRD, only to have developers point out several details you hadn’t considered during Monday’s review meeting.
-
Scenario 3: You’re a veteran product manager leading a team. One problem has been bothering you: different product managers produce varying quality requirements documents. You have to spend extra time reviewing others’ work—time you could have spent on product strategy research.
If one of these scenarios resonates with you, then you should try these five PRD-generating skills. One might just be your lifesaver.
This article will tell you: in what scenarios should you choose which skill?
The Five Skills in This Comparison
I’ve carefully selected five skills from skills.sh with installation counts ranging from hundreds to tens of thousands. Each skill has its own unique philosophy and use cases.
prd
Installation
npx skills add https://github.com/github/awesome-copilot --skill prdThis is a Skill from GitHub’s official awesome-copilot repository, with 17.5K installations on skills.sh. Its core process is divided into three stages:
Stage 1: Discovery — Before you start writing, it asks you three essential questions: What core pain point does the product solve? How do you measure product success? What are the constraints? The documentation explicitly states “Don’t assume context” — this is very important. The more experience you gain building software products, the more you’ll understand: finding market users before developing products is much better than developing products first and then looking for users.
Stage 2: Analysis & Scoping — Map out user flows and clarify non-essential feature boundaries (Non-Goals). This is especially helpful when ideas are still vague in early stages.
Stage 3: Technical Drafting — Output according to the “Strict PRD Schema” defined in the SKILL.md document, including five modules: Executive Summary, User Stories, AI Module Requirements (if applicable), Technical Selection, Risks and Iteration Roadmap.
What I love most about this Skill is its zero tolerance for vague language. The documentation provides explicit right/wrong examples:
# Vague (Wrong)
- Search should be fast and return relevant results
# Specific (Correct)
- Response time ≤200ms on 10k dataset
- Accuracy ≥85%Best for: Someone with a vague idea who needs to clarify requirements; or people with ideas but no professional product manager training.
Not for: Product teams in medium-to-large enterprises that need to follow strict processes and rigorous argumentation when developing new features or products.
to-prd
Installation
npx skills add https://github.com/mattpocock/skills --skill to-prdMatt Pocock is a big name in the TypeScript community, and his to-prd Skill takes a completely different approach:
No questions asked — it generates directly from the current conversation context.
The flow is simple:
- Explore the codebase first to understand the current project state
- Organize the core modules you need to build/modify
- Output using the PRD template, publish to Issue Tracker with the
ready-for-agenttag
This Skill assumes you already know what you want to build — you just need to document it. It doesn’t do requirements discovery, only requirements translation. In other words: this Skill assumes your ideas are correct. It just helps you consolidate scattered chat records into a proper checklist.
Best for: Product managers with engineering backgrounds, or PRDs for internal technical teams — you already know what to build, just need a properly formatted document for the agent to execute.
Not for: Scenarios that need help clarifying “what to build.” It won’t help you think through product decisions, just translate your thoughts into a PRD document.
prd-generator
Installation
npx skills add https://github.com/jamesrochabrun/skills --skill prd-generatorThis skill is the closest to an “enterprise-grade PM tool.” It includes a complete PRD template with 13 modules covering everything from problem clarification, goal setting, user personas and user stories, metrics, milestones, and more.
Recognizing that not every project needs such a rigorous PRD template (it’s not always necessary), it provides multiple scenario-specific versions: Standard, Lite, One-Pager (suitable for executives), Technical (focused on engineering), and Design (focused on UX).
It also references three metrics frameworks: AARRR (Pirate Metrics), HEART (Google User Experience Framework), and OKRs. You can choose the appropriate metrics system based on product type — something no other Skill offers.
The documentation includes a scripts/validate_prd.sh validation script that automatically checks PRD completeness — whether all sections are present, if user story formats are correct, and if Success Metrics are defined.
Best for: If you work in a large company with rigorous product initiation processes, if you’re designing a complex system from scratch, or if you need to deliver a professional, detailed product requirements document externally — this skill is the clear choice.
Not for: Personal projects, minor fixes, or situations where you just want to quickly create a demo. Its process is too lengthy.
writing-prds
Installation
npx skills add https://github.com/jamesrochabrun/skills --skill prd-generatorThis Skill is different from the three introduced above. Instead of giving you a template to fill out, it distills insights from 11 top product experts into a set of requirements document writing principles.
Some examples:
- Lead with why: Maggie Crowley (former Slack PM) says “The most important section is the first part — what’s the background and context, what’s the problem, and why does it matter now?”
- PR/FAQ forces clarity: Bill Carr (former Shopify executive) says that every time they design a new product, the first thing they do is write a news release, describing it from the user’s perspective. The product’s value must shine through the words, otherwise it shouldn’t be built.
- Demos before memos: Aparna Chennapragada (Google Product Director) puts it more directly: “If you’re not building prototypes, not hands-on validating what you actually want to build, you’re doing it wrong. Prompt sets are the new product requirements documents.”
This Skill collects insights from 11 top industry product experts and provides reference documents that further explain how to understand and apply these experts’ viewpoints to real scenarios. For example, regarding Bill Carr’s viewpoint:
Insight: The news release + FAQ process forces you to think through and articulate user value clearly before any development work begins.
Practical suggestions:
- Before starting development, write a mock news release (PR) and a list of FAQs
- Use the news release to describe target users, pain points, and solutions in objective, data-rich language
- Include a hypothetical release date to reflect project complexityHonestly, when I first saw this Skill, I thought it was a particularly innovative approach. Because when writing PRD documents, format is just a constraint on the final output, but thinking is the most valuable essence of a PRD document. This Skill’s uniqueness lies in not giving users a fixed process or template, but rather a set of thinking frameworks.
Best for: Product managers with some experience who want to improve their PRD foundational skills. It doesn’t teach you “format,” it teaches you “thinking.”
Not for: People who need immediate, tangible documents. It provides no templates or scripts — you need to apply these principles to create your own documents.
brainstorming
Installation
npx skills add https://github.com/obra/superpowers --skill brainstormingStrictly speaking, this isn’t a PRD Skill. But from a practical standpoint, it might be the most beginner-friendly PRD Skill for non-professionals.
If other PRD Skills teach you “how to write documents,” then brainstorming teaches you “how to think clearly before doing.” Its design philosophy is:
Think through the design before writing, confirm the approach before coding.
The soul of this Skill is a HARD-GATE rule:
“Do NOT invoke any implementation skill, write any code, scaffold any project, or take any implementation action until you have presented a design and the user has approved it.”
The most beginner-friendly feature of the brainstorming Skill for generating PRDs is: it asks users one question at a time, so beginners aren’t overwhelmed by too many questions. It also helps clarify requirements and then presents 2-3 options for users to choose from. Once the user confirms an option, it writes the design document.
Best for: For personal projects, non-professionals, or when you only have a vague idea but want to quickly produce a Demo, this Skill is the most friendly and hassle-free.
Not for: When your ideas are already very clear and you have complete confidence in the implementation details, just want to quickly build a Demo. This Skill isn’t the most efficient in that case.
Conclusion: Quick Selection Guide
| Scenario | Recommended Skill |
|---|---|
| Engineers or rapid idea validation | to-prd |
| Have ideas but non-professionals | prd |
| Rigorous, professional, complex product launches | prd-generator |
| Improve PRD writing methodology | writing-prds |
| Complete beginners | brainstorming |
What if I could only recommend one?
In most cases, I’d recommend brainstorming. Because it has the broadest applicability and low learning curve.
Related Reading
If you’d like to learn more about the brainstorming Skill, check out this article: Brainstorming
If you’d like to see more Skill comparisons and reviews, feel free to email us at: deepnotes.org@gmail.com