Competitor matrices are the most misused artifact in product. They turn into deck propaganda (your column all green checks, theirs all red) or a sprawl of 80 rows nobody reads. These 15 prompts produce honest, actionable matrices: the kind that surface real gaps, surprise the team, and feed next quarter’s roadmap. They cover feature parity, jobs-to-be-done coverage, pricing structure, and the rarer “what they do that we never thought of” axis.
TL;DR: Keep the matrix to 12-15 rows that change a buyer decision (start from the 15-25 features buyers actually evaluate in your category). Score your own column honestly with prompt 5 before anyone external sees it. Convert the weakest rows to roadmap with prompt 10, and only publish a comparison page after the marketing-safe pass in prompt 9. Re-verify every quarter; competitor data ages fast.
Who this is for
PMs scoping the competitive landscape, founders preparing for fundraising, GTM leads writing battle cards, and product marketers building comparison pages.
When not to use these prompts
Skip them if you have not used the competitors yourself for at least 30 minutes. Matrices generated off public marketing pages are unreliable because vendors overclaim. Skip them too when the goal is a sales battle card; use the battle-card format (prompt 15) instead of a raw matrix.
Which model to run these on (as of June 2026)
These prompts are model-agnostic, but the work splits cleanly:
- Structured matrix output (tables, scoring, gap extraction): Claude Sonnet 4.6 or Opus 4.7 hold formatting well across long tables; both ship with a 1M-token context, so you can paste several pricing pages at once. GPT-5.5 (Thinking) and Gemini 3.1 Pro are equally fine for the table work.
- Pulling current competitor facts: Use a model with live web access, then make a human verify every cell. As of June 2026, no model reliably reads a competitor’s feature list off a marketing page without inventing a “yes” somewhere. Treat any unverified cell as
unknown, not as a check.
Whatever you use, the rule is the same: AI drafts the structure, a human who has used the products fills the truth values.
Prompt anatomy / structure formula
A competitor-comparison prompt should always carry six elements:
- Role: who the AI plays (senior PM / solo founder / product designer / indie dev / growth lead).
- Context: stage (idea / MVP / growth / scale), team size, traffic or ARR, platform (web / iOS / Android), audience, constraints.
- Goal: one concrete deliverable — one matrix, one gap list, one comparison page, one battle card.
- Constraints: timeline (this sprint / this quarter), scope cuts, must-not-break (existing flows, billing, compliance).
- Output format: table, checklist, ticket-ready JSON, or labeled blocks you can paste straight into Linear / Notion / Jira.
- Examples / signal: 1-2 reference docs or competitors you like, plus 1 anti-example you want to avoid.
A note on placeholders: the templates below use square-bracket slots like [us] and [competitors]. Replace the whole bracket, including the brackets, before you run the prompt.
Best for
- Quarterly competitive landscape refresh
- Roadmap input — which gap to close, which to ignore on purpose
- Positioning re-anchoring
- Comparison page on the marketing site
- Investor / board competitive overview
15 copy-ready prompt templates
1. Feature parity matrix builder
The default. Tighter, lower row count than most teams attempt.
You are a product strategist. Build a feature comparison matrix between [us] and [3-5 competitors]. Limit to 12-15 rows that actually influence purchase decisions. For each row: feature name, what it means to a buyer in 1 line, status per competitor (yes / partial / no / unknown), severity if missing. Avoid vanity features.
Context: [category, our product, competitors]Variables to swap: us, competitors, category
Optimization: If the matrix feels like marketing fluff, add: “For every row marked yes, name the specific way the feature is delivered. If you cannot, mark unknown.”
2. JTBD-coverage matrix
Instead of a feature matrix, build a jobs-to-be-done coverage matrix: rows are the 6-8 jobs in [category], columns are competitors. For each cell: how well is this job covered (full / partial / unsupported), with one-line evidence. Highlight jobs where nobody scores "full".
Products: [paste]3. Pricing-structure comparison
Compare the pricing structure of [us] vs [competitors]. Rows: pricing model, free tier, trial, billing cadence, seat-based vs usage-based, lock-in / contract, enterprise add-ons, hidden costs. Output as a table. End with one observation about where pricing diverges from category norms.4. “What they do that we never thought of” pass
Forget our current roadmap. For each competitor in [list], name 3 things they do that surprised you or that we are NOT considering. Be specific: not "AI features", but the actual flow. Mark each: worth adopting / worth watching / not relevant.
Competitors: [list]5. Honest self-scoring
Given this draft comparison matrix, rate our column on each row from 1-5 honestly (1 = barely exists, 5 = best in category). Then estimate competitor scores. Flag any row where our score is the same or lower than 2 competitors — those are the gaps to address.
Matrix: [paste]6. Pricing-by-customer-size table
Show the effective monthly cost of [our product] vs [competitors] at 3 customer sizes: solo user, 10-seat team, 100-seat team. Include hidden costs (overages, add-ons, support tier). Use specific numbers from public pricing pages; mark any estimate.7. Feature freshness audit
For each row in our existing comparison matrix, check when we last verified the competitor data. Output: row, source (page / version / date), confidence level. Flag rows where the data is more than one quarter old — those need re-checking before quoting externally.
[paste matrix + last-verified dates]8. “Same name, different thing” disambiguator
Competitors call the same feature different names, and the same name can mean different things. For each of these 10 features, list how each competitor names it and whether the implementation is genuinely equivalent or merely shares a label.
Features + competitors: [paste]9. Comparison page draft (marketing-safe)
Convert this internal matrix into a marketing-site comparison page. Rules: never claim a green check we cannot prove, never put a competitor at zero unless verified, end with one differentiator paragraph (not a feature list). Output: H1 + 2-line subhead + 8-row table + closing paragraph.
Matrix: [paste]10. Gap-to-roadmap converter
From this matrix, extract the 5 rows where we are weakest. For each: estimated effort to close the gap (S/M/L), estimated impact on win-rate, dependency, and whether it is worth closing or worth ignoring strategically. Output as a 5-row table.
Matrix: [paste]11. Buyer-journey overlay
Overlay this competitor matrix onto the buyer journey (awareness, evaluation, trial, purchase, expansion). For each stage, list which competitor wins and on what dimension. End with the stage where our product is most differentiated and the stage where we lose most deals.
Matrix: [paste]12. Anti-feature list
List 5 things our competitors do that we deliberately do NOT do (no spam emails, no aggressive upsell, no required login, no third-party tracking, etc.). Frame each as a buyer-positive trait. This becomes positioning leverage, not a gap.13. Customer-quote-backed comparison
For each row of this comparison matrix, find or write a one-line customer-quote pattern from public review sites (G2, Capterra, App Store) that supports the claim. Mark each as: real quote (paste verbatim) or "AI-paraphrased — needs verification". Do not invent quotes.
[paste matrix]14. Quarterly delta report
Compare last quarter's competitor matrix vs this quarter's. Output: features competitors added, features they removed, pricing changes, positioning shifts. Hypothesize what each move signals about their roadmap.
Q-1: [paste]
Q0: [paste]15. Battle card extract
From this matrix, generate a 1-page sales battle card per competitor: their strengths (acknowledged), their weaknesses (specific, defensible), our wedge against them, 3 customer-question responses ("Why not them?"). Voice: confident, never disparaging.
Matrix: [paste]Two kinds of insight to extract
A finished matrix should hand you exactly two lists. Confusing them is how teams build the wrong roadmap.
| Insight type | What it is | What to do with it |
|---|---|---|
| Table-stakes gap | A capability every product in the category has and buyers expect. Missing it is a disqualifier. | Close it. This is defensive roadmap; it does not differentiate, it just keeps you in deals. |
| White-space opportunity | A job nobody scores “full” on (prompt 2), or something only one competitor does well (prompt 4). | Decide deliberately: own it as a wedge, or skip it and say so. This is your offensive roadmap. |
Prompt 5 surfaces table-stakes gaps; prompts 2 and 4 surface white space. Run all three before you write next quarter’s plan.
How often to re-verify
Competitor facts decay. A workable baseline for most teams, as of June 2026:
- Monthly: a light scan of competitor changelogs, pricing pages, and recent G2/Capterra reviews.
- Quarterly: a full matrix refresh and an honest re-score (prompts 7 and 5).
- Annually: a rebuild from scratch, including which 12-15 rows even belong in the matrix.
Fast-moving categories (AI tooling, anything with weekly model or pricing changes) need the quarterly cadence pulled monthly.
Common mistakes
- Building an 80-row matrix nobody reads — limit to 12-15 rows that change a buyer decision.
- Marking every competitor row red and yours green — destroys credibility internally and externally.
- Using competitor marketing pages as the only source — they overclaim too.
- Skipping the “what they do that we never thought of” pass — this is where roadmap input lives.
- Treating the matrix as a one-time artifact — must be re-verified each quarter.
- Building a marketing comparison page directly from the internal matrix — it needs the marketing-safe pass (prompt 9).
- Ignoring pricing structure — features can match while pricing model decides the deal.
How to push results further
- Use the product yourself for at least 30 minutes before scoring any competitor.
- Mark every row with a verification date and source — claims age fast.
- Run prompt 5 (honest self-scoring) before any external use of the matrix.
- Pair every gap with effort and impact — gaps without effort estimates are wishes.
- Always include an anti-feature list (prompt 12) — what you deliberately do not do is positioning.
- Refresh the matrix quarterly at minimum, monthly in a fast-moving category.
- Keep two versions: internal (honest) and external (marketing-safe). They are different artifacts.
- If you publish the external version, add comparison-table structured data. Marked-up comparison data is what ChatGPT, Perplexity, and Google’s AI summaries cite when a buyer asks “how does X compare to Y” — see Google’s structured data documentation for supported formats.
FAQ
- How many competitors should I include?: 3-5. More dilutes signal, fewer hides patterns. Pick by deal-frequency, not market hype.
- How many feature rows is right?: 12-15 in the final matrix. Start from the 15-25 features buyers in your category actually evaluate, then cut anything that does not move a decision.
- How do I keep the matrix honest?: Date every row, require evidence for every “yes”, run prompt 5 each quarter, and share it with sales for a reality check.
- Can AI scrape competitor data for me?: AI can suggest what to check and structure the table, but verification must be human. As of June 2026, AI-generated competitor claims off public sites are wrong often enough that an unverified cell should read
unknown, not “yes”. - Should the comparison go on our marketing site?: Only after the marketing-safe pass (prompt 9) and only if every claim is verifiable. Add structured data so AI engines can cite it.
- How does this differ from a battle card?: The matrix is structured comparison data. The battle card is a sales artifact derived from it (prompt 15).