Specs & PRDs

Write a user-centered problem statement covering who is blocked and why it matters

Create a six-frame storyboard that shows a user's journey from problem to solution

Write user stories in Mike Cohn format with Gherkin acceptance criteria

Map a workflow's activities and tasks into release slices for an MVP

Run a user story mapping workshop that outputs backbone activities and release slices

Split large stories and epics into smaller deliverable stories with proven patterns

Interview an unshaped idea into a verdict and design document before planning

Interview an idea into a PRD covering problem, success metrics and user journeys

Run a Socratic interview to turn a vague idea into goals and constraints

Write product requirements and PRDs through a PM-focused guided interview

Freeze a settled goal and its success criteria into an executable spec

Co-author proposals, technical specs and RFCs through iterative drafting and review

Co-write PRDs, RFCs and design docs from messy context, outline first

Turn the current conversation into a spec and publish it to your issue tracker

Write an implementation spec with scope, decision log, open questions and migration plan

Write a product requirements document for a new feature with multi-model input

Write product feature specs with acceptance criteria, scope and risks

Plan an MVP phase from a user story and split it with SPIDR

Clarify what a phase delivers with a Socratic spec and falsifiable requirements

Scope the simplest MVP or prototype that tests current hypotheses

Explore ideas and clarify requirements with an OpenSpec thinking partner

Turn a rough idea into an OpenSpec proposal with design, specs and tasks

Merge delta spec changes into main specs without archiving the change

Write or revise an MVP requirements document with scope and acceptance criteria

Write a project brief with problem space, constraints, audience and success criteria

Write design handoff specs with measurements, behaviors, assets, states and edge cases

Question a design brief before building and record unasked decisions as assumptions

Gather requirements through guided dialogue and generate a scored PRD

Clarify fuzzy requirements with focused questions before any coding starts

Write PRDs with user stories that feed ralph-tui beads or prd.json

Write requirements, acceptance criteria and scope so a team knows when it is done

Create, review and comment on PRDs, briefs and RFCs written as Figma specs

Write business and product requirements documents with canonical templates

Turn call transcripts into a framing document on the problem worth solving

Shape problems and solution options collaboratively, iterating on requirements

Turn abstract ideas into PRD-style specs with a clear problem and success metrics

Manage typed specification sections, approvals and change records for a project

Write user stories and check for duplicates in Linear, GitHub Issues or Jira

Generate product requirements documents and publish them to Confluence or other wikis

Draft requirements documents from Simulink models in Requirements Toolbox or YAML

Write system specs, architecture and test plans for model-based design algorithms

Write specs and validation plans for plant models used in closed-loop simulation

Review a Chorus proposal's PRD and task drafts against the originating idea

Claim ideas in Chorus, run elaboration rounds and set up proposal creation

Claim ideas in Chorus, run elaboration rounds and prepare for proposals

Draft Chorus proposals with documents, tasks and a dependency graph for review

Draft Chorus proposals with document and task drafts, then validate and submit

Review a submitted proposal for completeness, task sizing and coverage gaps

Post a structured verdict after auditing PRD and task drafts against the idea