Build a Product Roadmap Prompt That Prioritizes by Capacity

Most roadmap prompts you'll find online are a list of 25 questions to paste one at a time. They produce paragraphs, not a ranked plan. A real product roadmap prompt does one job: it takes your features, a scoring model, and a hard capacity number, and it hands back a prioritized roadmap you can defend in a planning meeting.

The gap is the capacity. Ask a model to "prioritize this backlog" and it will rank everything and quietly assume infinite engineering time. That's the part that breaks. A roadmap that ignores how many points the team can actually ship is a wishlist.

This walks through a reusable prompt that wires RICE or Now-Next-Later to a {{capacity}} variable and locks the output to a ranked table with a one-line rationale per item.

What you can do with a roadmap prompt

• Rank a raw feature list by RICE (Reach, Impact, Confidence, Effort) without doing the arithmetic by hand
• Split the ranked list into Now, Next, and Later against a real sprint or quarter capacity
• Flag the features that don't fit the current {{capacity}} so they're parked, not forgotten
• Surface the two or three items where Confidence is low and a spike is cheaper than building
• Rewrite the same backlog under a different lens (revenue-first vs. retention-first) by swapping one variable
• Produce a stakeholder-ready summary that names the trade-off behind each cut

Why a capacity number changes the output

Here's the opinionated part. Most "AI roadmap" content treats prioritization as a sorting problem. It isn't. Sorting tells you the order. It doesn't tell you where the line is.

A roadmap prompt earns its place by drawing that line. Feed it {{capacity}} (say, 40 story points this quarter) and the prompt fills Now until the budget runs out, then pushes the rest to Next and Later with a reason. That single constraint is what turns a ranked list into a plan a team can commit to.

Anatomy of the prompt

The structure that holds up across long backlogs puts the role and scoring rules first, the data in the middle, and the output contract last. Models weight the most recent tokens, so the contract belongs at the end where a long pasted backlog won't bury it.

Role: You are a product prioritization assistant.

Scoring model: {{scoring_model}}   // RICE or Now-Next-Later
Team capacity this period: {{capacity}}   // e.g. 40 story points
Strategic lens: {{strategic_lens}}   // e.g. retention-first

Features:
{{feature_list}}   // one per line: name, rough effort, any notes

Output format:
1. A ranked table: Feature | RICE score | Effort | Tier (Now/Next/Later)
2. A cut line marking where {{capacity}} runs out
3. One sentence per deferred item explaining the trade-off
Return only the table and the rationale list. No preamble.

How the models behave on this job

Model behavior diverges once the feature list gets long. Claude holds the section structure and keeps the table columns aligned across 30-plus rows before it drifts. GPT-4o computes the RICE math a little more reliably but starts dropping the rationale column on long inputs unless you restate "one sentence per deferred item" on the final line. Gemini is fine for the ranking but tends to editorialize, adding strategy commentary you didn't ask for. None of this is fatal. You just need to know which one to nudge.

Step-by-step usage

1. Gather inputs

Pull your feature list into one place. Each line needs a name and a rough effort estimate. Notes are optional but help the Impact score.

2. Fill the variables

Set {{scoring_model}}, {{capacity}}, and {{strategic_lens}}. The capacity number is the one that matters most, so don't leave it vague. "A lot" isn't a number.

3. Run the prompt

Paste the filled prompt. Read the cut line first. That's where the real decision lives.

4. Argue with it

The ranking is a draft. If a feature you know is strategic landed in Later, that usually means its Confidence or Reach input was too low. Fix the input, rerun, don't override the output by hand.

5. Reuse next quarter

Swap {{feature_list}} and {{capacity}}. Same contract, new plan.

Prompt-craft patterns that make it stick

Pattern one: make capacity a hard stop. Don't write "consider the team's capacity." Write "fill Now until {{capacity}} is exhausted, then stop." A soft instruction gets ignored on long lists. A hard one forces the cut.

Fill the Now tier until cumulative effort reaches {{capacity}}.
Everything past that line goes to Next or Later.

Pattern two: lock the rationale to one sentence. Models love to write a paragraph per feature. One sentence keeps the output skimmable and forces the model to name the single biggest trade-off instead of hedging across five.

Pattern three: separate scoring from sequencing. Ask for the RICE score and the tier as two columns. When they're fused, the model fudges the math to match its gut on the tier. Keep them apart and you can audit whether the score actually justifies the placement.

Variables you'll set

Getting started

1. Drop your backlog into {{feature_list}}, one line each.
2. Decide the scoring model and set {{scoring_model}}.
3. Put a real number in {{capacity}}.
4. Run the prompt and read the cut line.
5. Check two or three RICE scores by hand to confirm the model didn't invent Reach.
6. Rerun with a corrected input rather than editing the table.
7. Save the filled prompt so next quarter is a two-variable swap.

For the full connected version, the Connected Roadmap Alignment Agent Pack runs this against live data sources so you're not pasting the backlog by hand every cycle.

When one prompt isn't enough

Prioritization is one job in a planning cycle. The retro that feeds next quarter's inputs is another, covered in the sprint retrospective prompt walkthrough, and if you're still deciding whether a curated pack beats a free template, the guide to choosing a reusable prompt pack lays out the trade-offs. A backlog full of stale tickets makes any roadmap worse, so the Backlog Cleanup Agent Pack is a reasonable first pass before you prioritize.