Convert requirements into structured PRDs for agents
Turn the current conversation directly into a published PRD - no interview, just synthesis of what's already been discussed.
Maintainer of this project? Claim this page to edit the listing.
1.0.1Add to Favorites
Why it matters
Transform vague feature requests into detailed, structured Product Requirements Documents that align development teams and AI agents on what to build, which modules to touch, and how changes fit into the existing codebase architecture.
Outcomes
What it gets done
Quiz stakeholders about requirements and affected modules before writing specs
Document architectural decisions and shared language in CONTEXT.md files
Generate PRDs that specify implementation scope and design constraints
Integrate with GitHub or Linear to pull context from existing issues and tickets
Install
Add it to your toolbox
Run in your project directory:
curl -fsSL https://spark.entire.vc/get/ag-to-prd | bash Overview
To Prd
Synthesizes the current conversation and codebase understanding into a structured PRD - problem, user stories, implementation and testing decisions - and publishes it to the issue tracker. Use when a feature has already been discussed in conversation and needs to become a published, agent-ready PRD without a separate interview.
What it does
To Prd takes the current conversation and codebase understanding and produces a PRD without interviewing the user - it synthesizes what's already been discussed rather than asking new questions. It requires the project's issue tracker and triage-label vocabulary to already be configured (via /setup-matt-pocock-skills if not), and publishes the finished PRD there with a ready-for-agent triage label applied, needing no further triage step.
When to use - and when NOT to
Use it when the request matches turning the current conversation into a PRD and publishing it to the project issue tracker. Before writing, it explores the repo if that hasn't already happened, uses the project's own domain glossary vocabulary throughout the document, and respects any ADRs in the area being touched rather than re-litigating settled decisions.
Inputs and outputs
Before writing, it sketches the seams at which the feature will be tested, preferring existing seams to new ones and the highest seam possible - the fewer seams across the codebase, the better, with one as the ideal - checking with the user that the chosen seams match their expectations. The PRD itself follows a fixed template: a Problem Statement and Solution written from the user's perspective, an extensive numbered list of User Stories in the form "As an [actor], I want a [feature], so that [benefit]" covering all aspects of the feature, Implementation Decisions (modules, interfaces, technical clarifications, architectural decisions, schema changes, API contracts) that deliberately excludes file paths or code snippets since they go stale quickly - except a prototype-derived snippet that encodes a decision more precisely than prose can (a state machine, reducer, schema, or type shape), trimmed to just the decision-rich parts rather than a working demo - Testing Decisions (what makes a good test, focused on external behavior not implementation details, plus prior art from similar tests already in the codebase), an Out of Scope section, and Further Notes.
1. As a mobile bank customer, I want to see balance on my accounts, so that I can make better informed decisions about my spending
Integrations
Publishes directly to the project's configured issue tracker with the ready-for-agent triage label, and cross-references the project's domain glossary and existing ADRs rather than introducing new vocabulary or re-deciding settled architecture questions.
Who it's for
Teams that have already talked through a feature in conversation and want that discussion synthesized straight into a structured, agent-ready PRD - user stories, implementation and testing decisions, and scope boundaries - without a separate requirements-gathering interview.
Source README
When to Use
Use when this workflow matches the user request: Turn the current conversation into a PRD and publish it to the project issue tracker - no interview, just synthesis of what you've already discussed.
_Source: mattpocock/skills (MIT)._This skill takes the current conversation context and codebase understanding and produces a PRD. Do NOT interview the user - just synthesize what you already know.
The issue tracker and triage label vocabulary should have been provided to you - run /setup-matt-pocock-skills if not.
Process
Explore the repo to understand the current state of the codebase, if you haven't already. Use the project's domain glossary vocabulary throughout the PRD, and respect any ADRs in the area you're touching.
Sketch out the seams at which you're going to test the feature. Existing seams should be preferred to new ones. Use the highest seam possible. If new seams are needed, propose them at the highest point you can. The fewer seams across the codebase, the better - the ideal number is one.
Check with the user that these seams match their expectations.
- Write the PRD using the template below, then publish it to the project issue tracker. Apply the
ready-for-agenttriage label - no need for additional triage.
Problem Statement
The problem that the user is facing, from the user's perspective.
Solution
The solution to the problem, from the user's perspective.
User Stories
A LONG, numbered list of user stories. Each user story should be in the format of:
- As an
, I want a , so that
This list of user stories should be extremely extensive and cover all aspects of the feature.
Implementation Decisions
A list of implementation decisions that were made. This can include:
- The modules that will be built/modified
- The interfaces of those modules that will be modified
- Technical clarifications from the developer
- Architectural decisions
- Schema changes
- API contracts
- Specific interactions
Do NOT include specific file paths or code snippets. They may end up being outdated very quickly.
Exception: if a prototype produced a snippet that encodes a decision more precisely than prose can (state machine, reducer, schema, type shape), inline it within the relevant decision and note briefly that it came from a prototype. Trim to the decision-rich parts - not a working demo, just the important bits.
Testing Decisions
A list of testing decisions that were made. Include:
- A description of what makes a good test (only test external behavior, not implementation details)
- Which modules will be tested
- Prior art for the tests (i.e. similar types of tests in the codebase)
Out of Scope
A description of the things that are out of scope for this PRD.
Further Notes
Any further notes about the feature.
Limitations
- Requires the upstream tool, account, API key, or local setup when the workflow names one.
- Does not authorize destructive, production, paid, or external-message actions without explicit user approval.
- Validate generated artifacts or recommendations against the user's real sources before treating them as final.
FAQ
Common questions
Discussion
Questions & comments ยท 0
Sign In Sign in to leave a comment.