River
Y CombinatorBacked by Y Combinator

Product & DesignFree tool

PRD Generator for Product Requirements

A PRD your team can review, from a few lines about your feature: the problem, goals, ranked requirements with tests, non-goals and open questions.

Helpful to include

Free to start · Opens in your River workspace, ready to edit and share

How to write a PRD

A PRD (product requirements document) sets out what a feature must do, who it's for and why, so the team can agree before anyone builds it. To write one, describe the problem with real evidence, set goals you can measure, and list requirements in priority order, each with a test. Then record what you've deliberately left out and the questions nobody has answered yet.

Aim for the shortest PRD that settles the decisions. Every line should answer something a designer, engineer or tester would otherwise have to ask you.

A hand sketching a user flow on paper, with screens, arrows and yes or no branches, on a wooden desk beside a ruler
Every no branch in a flow is a decision the PRD should make. Photo: Kelly Sikkema on Unsplash

Choose a one-page brief or a full PRD

Decide how much detail the work needs before you start. A one-page brief holds the problem, goals, up to six requirements, the non-goals and the open questions. The full version adds user flows, constraints, dependencies and risks. Write the full version when any of these is true:

  • More than one team has to build or support it
  • It touches payments, personal data or a contract
  • The flow has many branches, or a mistake would be costly to undo

Even the short version has fixed parts. In Shape Up1, Ryan Singer's book on how Basecamp plans product work, every pitch has the same five ingredients. They are the problem, the appetite (how much time it's worth), the solution, the rabbit holes to avoid and the no-gos.

Start with one specific problem

Write the problem before any solution. Singer's advice is that the best problem definition is a single specific story that shows why the status quo doesn't work1. Make it one real customer's story: what they were trying to do, and where it broke.

One story could be a fluke, so list the evidence that it isn't, each item with its source: support tickets, lost deals, usage numbers, interview notes. If your evidence is interview transcripts, first sort them into findings counted by how many people raised each one.

State the appetite too. A fix worth 2 weeks looks nothing like one worth a quarter, and Singer writes that stating the appetite prevents unproductive conversations1.

Finish with goals: the number you expect to move, and where it stands today. If you don't know today's figure, write "baseline to confirm" instead of guessing.

Write requirements as what, not how

Each requirement says what the product does for someone, never how to build it. Joel Spolsky, a former Microsoft program manager who later co-created Stack Overflow, drew this line in 2000. A functional spec, he wrote, describes how a product will work entirely from the user's perspective2. Data structures, databases and tools belong in a separate technical spec.

Give each requirement one priority word that everyone reads the same way. The Agile Business Consortium's guide to MoSCoW prioritization has a sharp test for a Must: ask what happens if the requirement isn't met. If there's any way around it, even a manual and painful one3, it isn't a Must.

Three priority words

PriorityWhat it meansAsk
MustRequired for the release to go out"Would we cancel the project without it?"
ShouldExpected, but can be dropped for a stated reason"Would leaving it out hurt, even with a workaround?"
MayOptional, and the first thing cut when time runs short"Would leaving it out cost little?"

MoSCoW calls the third level Could Have, and adds a fourth: Won't Have this time.

Keep the Musts lean. The same guide puts the safe level at 60% of the effort or less. Everything that isn't a Must is your room to cut when estimates slip.

Attach a test anyone could run: an action and the result they should see. Fast, easy and secure can't be tested until you trade them for a number or a visible outcome.

Draw the scope line

Non-goals settle scope arguments while they're still cheap. Spolsky's reason: everyone on a team tends to have pet features they just can't live without2, and building them all would take forever. List what a reader might reasonably expect but won't get in this release, each with a one-line reason.

MoSCoW's Won't Have this time label does the same job. The Agile Business Consortium notes that recording these items stops them from being informally reintroduced later3.

Finally, note the constraints the team must work within, such as an existing sign-in system or a fixed launch date, and the teams or vendors you depend on.

ExamplePart of a one-page briefAn illustrative example written for this guide

Problem: Ana owns a cleaning company and bills the same 30 clients each month, rebuilding every invoice by hand. Last year, 140 support tickets asked for repeat billing.

R1 (Must): An owner can set an invoice to repeat monthly. Test: a repeating invoice dated January 31 creates the next one on the last day of February.

R2 (Should): The owner gets an email when a repeat invoice goes out. Test: the email arrives within 5 minutes of sending.

R3 (May): An owner can pause a repeat. Test: a paused invoice creates nothing on its next date.

Non-goal: Amounts that change with usage. Every ticket asked for a fixed monthly fee.

Open question: Do repeat invoices send automatically, or wait for approval? Owner: finance lead, before design starts.

  • What, not how. No line names a database, a scheduler or a screen layout.
  • Tests surface decisions. The January 31 test forces a choice about short months before anyone codes it.
  • Scope carries its reason. The non-goal points to the tickets, so the debate doesn't restart in review.

Walk the flow, including what goes wrong

Lay out the main path as short numbered steps, then each way it can fail: a wrong password, an expired link, a declined card. Spolsky points out that every error case is a decision somebody has to make2. If nobody decides, nobody can write the code.

Changing a flow that already exists? A user flow and journey map shows the routes people actually take today, including steps nobody designed.

Then name the risks. Marty Cagan, who founded the Silicon Valley Product Group, sorts product risk into four kinds4. Write one line for each, with what you'll do about it:

  • Value: will customers buy it, or users choose to use it?
  • Usability: can people figure out how to use it?
  • Feasibility: can engineers build it with the time, skills and technology you have?
  • Business viability: does it work for sales, legal, finance and the rest of the business?

Mark assumptions, then close the open questions

A first draft is full of guesses: who the users are, how many there will be, what security will allow. Label each one as an assumption so nobody mistakes it for a fact. Spolsky flagged open issues in a special style so he could search for them2, and expected every one to be settled before programmers started.

Every open question needs an owner, by role if you don't have a name, and a deadline for the answer. Otherwise it tends to get answered in code, by whoever reaches it first.

Check an AI draft line by line

AI writing tools can confidently state numbers, quotes and dates that are false. NIST's profile of generative AI risks calls this confabulation5. If a tool wrote your first draft, check every figure you didn't supply.

Before you share your PRD

  • The problem is one specific story, backed by evidence with sources
  • Each goal has today's number, or says baseline to confirm
  • Requirements say what, not how, each with one priority word and a test
  • Musts pass the cancel test and take no more than 60% of the effort
  • Non-goals carry reasons, and failure paths and risks are written down
  • Assumptions are labeled, and every open question has an owner and a deadline

Want to see a finished one first? The PRD template comes filled in with a worked example. Or describe your feature in the box at the top of this page, and River drafts the PRD with each assumption marked. Once it's agreed, turn the Musts into user stories with acceptance criteria.

How it works

Start with a few lines on what you're building and why, and paste or attach any evidence you have: ticket counts, interview notes or an old spec. River writes the PRD in your workspace, using only the facts and figures you supply. It labels anything it had to infer as an assumption, so you can tell its guesses from your facts.

Pick a one-page brief, or the full PRD with user flows, constraints and risks. When it's done, River can cut the scope to the smallest release that still solves the problem, or turn the Must requirements into user stories.

  1. Describe the feature

    Write a few lines on what you're building and why. Paste or attach any evidence or an old spec.

  2. River drafts the PRD

    Problem, goals, ranked requirements with tests, non-goals and open questions, using only the facts you gave it.

  3. Check the assumptions

    River names the two or three assumptions most worth checking. Confirm them, or correct anything it got wrong.

  4. Edit and share it

    Change anything, ask River to tighten the scope or write user stories, then share it with your team.

What you get

  • A summary and problem statement that quote your figures exactly, with any gaps clearly marked
  • Goals, each with a way to measure it, and "baseline to confirm" where you gave no number
  • A numbered requirements table, each ranked Must, Should or May with a test someone can run
  • Non-goals a reader might reasonably expect, each with the reason it's out of this release
  • In the full PRD, the main user flow and its failure paths, plus constraints and risks
  • Open questions with a suggested owner, and every inference labeled as an assumption to confirm

Common questions

What is a PRD?

A PRD, or product requirements document, is the shared description of a feature that design, engineering and testing all work from. A good one covers the problem and its evidence, measurable goals, prioritized requirements with tests, non-goals and open questions. It says what to build and why; how to build it goes in a separate technical document.

Should a PRD be one page?

Often, yes. A change one team can build usually fits on a page: the problem, goals, up to six requirements, non-goals and open questions. Write the full version when the work spans several teams, involves payments or personal data, or would be hard to reverse.

What's the difference between a PRD and user stories?

A PRD covers the whole feature and the reasoning behind it, so people can agree on scope. User stories slice that agreed scope into small pieces a team can build and test one at a time. Write the PRD first, then turn its Must requirements into stories. River can do that next, in the same conversation.

Will River make up numbers I don't have?

No. River works only from the facts, figures, names and dates you give it. Anything it infers, such as who the main users are, is labeled as an assumption, and anything essential but unknown is flagged to confirm. A goal with no starting number says "baseline to confirm" instead of showing an invented figure.

Should a PRD include technical details?

Only the constraints the builders must respect, such as the payment provider you already use, where customer data must be stored, or a launch date. Keep the PRD to the problem and the behavior people need, and let engineers choose the implementation in their own design document. Mixing the two makes both harder to review.

How do I write a PRD with River?

Type a few lines in the box at the top of this page about what you're building and why, and paste any evidence you have. Choose a one-page brief or the full PRD. River writes it into your free River workspace with every assumption marked, then can tighten the scope or turn the Musts into user stories.

Is the PRD generator free?

Yes, it is free to start. Your PRD opens in a River workspace, where you can edit it, share it with your team or ask River to change it. Paid plans add more AI use and access to the most advanced models.

Sources

  1. Shape Up. “Write the Pitch.” basecamp.com (opens in a new tab)

  2. Joel on Software. “Painless Functional Specifications – Part 2: What’s a Spec?” joelonsoftware.com (opens in a new tab)

  3. Agile Business Consortium. “What is MoSCoW Prioritization?” agilebusiness.org (opens in a new tab)

  4. Silicon Valley Product Group. “The Four Big Risks.” svpg.com (opens in a new tab)

  5. NIST. “Artificial Intelligence Risk Management Framework: Generative Artificial Intelligence Profile (NIST AI 600-1).” nvlpubs.nist.gov (opens in a new tab)

Built by

Chandler Supple

Co-founder & CEO, River

Chandler has spent the last six years working in AI, building tools for millions of users and Fortune 100 companies. In 2025, he co-founded River to build a new kind of operating system for AI agents.

Reviewed by

Brian Joseff, Co-founder, River