Skill

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.

Works with githublinear

Maintainer of this project? Claim this page to edit the listing.


78
Spark score
out of 100
Updated 26 days ago
Version 1.0.1

Add 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

01

Quiz stakeholders about requirements and affected modules before writing specs

02

Document architectural decisions and shared language in CONTEXT.md files

03

Generate PRDs that specify implementation scope and design constraints

04

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

  1. 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.

  2. 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.

  1. Write the PRD using the template below, then publish it to the project issue tracker. Apply the ready-for-agent triage 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:

  1. As an , I want a , so that
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

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.