Build a Decision Matrix With AI
Ask AI "which option is best?" and it returns a one-line pick with the criteria hidden and unknowns scored like facts. Here's how to build a decision matrix with AI: options against weighted criteria you approve, a reason per score, unknowns kept separate, and a sensitivity check.
Build a Decision Matrix PromptThe one-line pick that hides the whole decision
You have three tools to choose between, so you ask the AI which one to pick. Back comes a confident answer: "Go with Tool B — strong automation, good integrations, reasonable pricing." It sounds decisive, and it settles nothing you can defend. Reasonable pricing by what measure, against what budget? Integrations that matter to whom? Is automation worth more than setup speed here, or less — and who decided? The recommendation arrived with the criteria, the weights, and the reasoning all compressed into three adjectives, so there's nothing to check and nothing to argue with. When a teammate asks "why not Tool C?", all you have is the model's word.
A real decision needs its reasoning laid out, not summarized away — and that's what a decision matrix does: the options down one side, the criteria across the top, a weight on each criterion, a score in each cell, and a reason behind every score. This guide is how to build a decision matrix with AI so the whole decision is visible and reviewable: criteria tied to your goal, weights you approve, scores with rationale, unknowns kept out of the numbers, and a check for how fragile the winner is. NewPrompt helps you shape it: the Markdown Output Builder builds a prompt that returns the matrix in a fixed structure — a scoring table plus the sections around it — instead of a paragraph. But it's honest about the limit: it doesn't score your options, weight your criteria, validate a number, or make the call. You run the prompt on your own decision in your own AI tool, and what comes back is a candidate matrix you review, not a verdict to adopt.
Why a pros-and-cons list isn't a decision matrix
A pros-and-cons list feels like analysis, but it leaves out everything that makes a decision defensible. It doesn't hold the options to the same criteria, so Tool A gets judged on price and Tool B on features and you're comparing apples to nothing. It doesn't say what matters more, so a long list of small pros can quietly outvote one decisive con. And it blends what's known with what's guessed, so a confident-sounding pro may be resting on a number nobody checked. A decision matrix is the list turned into something you can inspect. It makes these parts explicit and separate:
- Options and criteria, fixed for everyone — every option scored on the same criteria, so the comparison is like-for-like instead of each option judged on its best feature.
- A weight on each criterion — what actually matters more, stated as a number you can argue about, so a pile of minor advantages can't outrank the one thing that counts.
- A score with a reason — not just "Tool B: 4" but why it's a 4, so a reviewer can disagree with the reasoning instead of just the number.
- Evidence, where there is any — the source or fact behind a score, so "reasonable pricing" becomes a figure someone can check rather than an impression.
- Unknowns, kept out of the scores — the things nobody actually knows yet, marked as unknown instead of quietly scored low and buried in the total.
- A sensitivity check — which weight or score, if it changed, would change the winner, so you know whether the result is solid or one nudge from flipping.
Step 1: Fix the options, the criteria, and what you're deciding for
A matrix is only as good as its criteria, so start there — and tie them to the decision, not to the options. Name the options, then name what a good choice has to deliver for this specific situation: not "the best support tool" but "the best fit for a small team that needs fast setup, a reliable shared inbox, and predictable cost." That goal is what makes a criterion legitimate — each one should trace back to it. Ask the model to propose criteria from the goal, then hold them to a standard: each criterion distinct from the others (not "ease of use" and "usability" as two rows), each one you can score by explaining ("setup effort for a non-technical admin") rather than a vague virtue ("strategic," "powerful"), and no criterion smuggling in two ideas at once.
One separation matters before any scoring starts: a must-have is not a criterion. "Must integrate with our email provider" isn't something Tool A does 60% well — it either does it or it disqualifies the option, and folding it into a weighted score lets a high automation score paper over a dealbreaker. So pull the hard constraints out into their own list, checked first: an option that fails a must-have is out, not merely marked down. The Product Manager Role Prompt is a useful lens here — its decision criteria weigh impact, effort, and risk the way a working PM does, which helps when you're deciding what a "good choice" even means. It shapes how the criteria are reasoned about; it doesn't decide them for you.
Step 2: Set the weights — then make the model hand them back for approval
Weights are where the real decision hides, so they're the part you must not let the model set silently. Every weighted score already contains a judgment about what matters more, and if the AI picks the weights, it's made the most important call in the whole matrix before you saw it. So split the job: let the model propose weights with a reason for each ("setup speed weighted highest because the team needs to be live in a week"), but treat those as a draft you approve, adjust, or overrule. The reason is the point — a weight with a rationale is a claim you can accept or reject; a bare number is just the model's preference wearing a decimal.
It helps to keep the weights legible: a small set of criteria rather than fifteen, weights that add up to something clean (a hundred, or shares of it), and the high weights explicitly justified, because a criterion carrying a third of the decision deserves a sentence saying why. And weights aren't universal — the finance lead and the support lead will reasonably weight cost and capability differently, which is a feature, not a problem. A good matrix makes that visible: it's the artifact two people with different priorities can look at together and see exactly where they diverge, instead of arguing past each other about the conclusion. The matrix doesn't resolve that disagreement; it locates it.
Step 3: Score on one scale, with a reason in every cell
Now the scores — and the discipline is one scale, applied the same way to every cell. Pick a range (1 to 5 is plenty) and define what the ends mean, so a 5 on "cost" and a 5 on "automation" represent the same level of good, and Tool A's 3 means the same thing as Tool C's 3. Then require a short reason for each score, not just the number. "Automation: 2 — supports rules but no multi-step workflows" is a score a reviewer can check and challenge; "Automation: 2" is a number to take on faith. The reasons are what turn the matrix from a spreadsheet of opinions into a set of claims, and claims are what you can actually review.
Where a score rests on a real fact, attach it: the price tier, the integration the docs confirm, the benchmark you ran. That evidence is what stops "reasonable pricing" from being an impression — it becomes a figure a teammate can verify, or challenge with a better one. But hold the standard honestly: the AI is scoring from what you and it know, and it can be wrong about a feature, misread a tier, or rate something generously. The scores it produces are a first pass to pressure-test, not measurements — every one is a claim with a reason attached, and the review is reading those reasons, not trusting the total they add up to.
Step 4: Keep what nobody knows out of the numbers
The most damaging move in a scored matrix is turning a blank into a low number. When the model doesn't know Tool B's exact price, or whether Tool C supports an integration, the tempting thing — and the thing it'll often do unasked — is to score it low and move on. Now a gap in your information is indistinguishable from a genuine weakness, and it's dragging down a total as if it were a fact. Tell the model the rule directly: if a value isn't known, mark it unknown — do not assign a score for it. An unknown is a question to answer, not a point to deduct.
Pull the unknowns into their own list next to the matrix, because they change what the result means. A winner that's ahead on fully-scored criteria is a different thing from a winner that's ahead only because its most important cell is an unfilled "unknown" the model didn't dare score. A truthful output says which is which: it scores what's known, lists what isn't, and marks any recommendation resting on an unknown as provisional — good only until you go get the missing fact. That's not the matrix hedging; it's the matrix telling you the truth about how much of the decision you can actually make right now.
Step 5: Test how fragile the winner is — then make the call
A number at the bottom of a column is not a decision, and the last step is to find out how much that number can be trusted. Ask the model for a sensitivity check: which single weight, if you nudged it, would change the winner? Which score, if it's wrong, flips the ranking? If cost weighted a little higher would put Tool C on top, or if Tool B only wins while its unknown price is assumed favorable, the "winner" is balanced on a knife-edge and the right label is "not a stable decision." A matrix where the top option holds across reasonable weight changes tells you something; one where the winner swaps every time you touch a slider tells you the criteria are close and the choice is really yours to make on judgment.
Then take the matrix for what it is: a structure for the decision, not the decision. The weighted total organized the conversation — it made the criteria explicit, the trade-offs visible, and the disagreements specific — but it didn't decide anything, and treating the highest number as the answer just launders a judgment call as arithmetic. You own the criteria, the weights, the reading of the scores, and the trade-off you're willing to accept; for anything with real stakes — a vendor contract, a financial or legal or security decision — that ownership sits with the domain owner or a professional, not a total in a table. NewPrompt gives you the structure to think the decision through in the open; which option you choose, and what you're trading away to choose it, stays with you.
Common mistakes
The habits that make a matrix look rigorous while deciding nothing honestly:
- Judging each option on different criteria. Fix one set of criteria, tied to the goal, and score every option against all of them — otherwise you're comparing each option's best angle.
- Letting the model set the weights. Weights are the real decision; have the AI propose them with reasons, then approve, adjust, or overrule them yourself before any scoring counts.
- Scoring without a reason. A cell should carry a short rationale you can challenge, not a bare number — the reasons are the reviewable part, the total isn't.
- Turning unknowns into low scores. Missing information is an unknown to go resolve, not a point to deduct; scoring it low buries a gap inside the total as if it were a weakness.
- Skipping the sensitivity check. If a small weight change swaps the winner, the decision isn't stable — say so, instead of presenting a knife-edge result as settled.
- Reading the highest total as the decision. The weighted score structures the trade-off talk; it doesn't make the call — that stays yours, and NewPrompt doesn't score, validate, or decide it for you.
A worked example: three support tools, scored in the open
Watch a one-line "which tool?" produce a verdict with the reasoning hidden, then a matrix-first prompt lay out the criteria, weights, scores, and the unknown that keeps the answer provisional.
A one-line "which tool?" returns a verdict with the criteria and weights hidden; a matrix-first prompt lays out weighted criteria you approve, a reason per score, the unknown cost it refuses to score, and a sensitivity check — a provisional recommendation you confirm and ownTHE DECISION:
Choose one of three customer-support tools (A, B, C) for a small team
that needs fast setup, a reliable shared inbox, basic automation, and
predictable cost. Must integrate with our current email provider.
THE WEAK ASK, AND WHAT IT GIVES BACK:
ask: "Which support tool should we choose?"
answer: "Go with Tool B -- strong automation, good integrations, and
reasonable pricing."
why you can't defend it:
- no criteria, no weights -- what mattered, and how much?
- "reasonable pricing" cites no figure; Tool B's cost may be unknown
- every option judged on its best feature, not the same yardstick
- would the pick change if cost mattered more? no way to tell
A MATRIX-FIRST PROMPT:
Build a decision matrix before recommending an option.
Decision + options + goal: [paste the four lines above]
Output, in this order:
- must-have constraints (checked first; a fail disqualifies)
- criteria table: name | definition | proposed weight | why this weight
- scoring table: each option x each criterion, 1-5, with a reason per cell
- unknowns: values not known -- listed, NOT scored
- sensitivity: which weight or score change would flip the winner
- recommendation LAST, and provisional if it rests on an unknown
Rules:
- Do not invent pricing or integration facts; mark them unknown.
- Weights are proposals for me to approve, not final.
- Separate must-haves from weighted criteria.
PART OF WHAT COMES BACK (a candidate you review):
Must-have: email-provider integration -- UNKNOWN for Tool B (confirm first).
Criteria (proposed weights, for your approval):
setup speed 25 | shared-inbox reliability 25 | automation 20 |
predictable cost 20 | reporting 10
Scores (1-5, reason per cell), e.g.:
Tool B / automation: 5 -- multi-step workflows + rules (from docs)
Tool B / predictable cost: UNKNOWN -- public pricing not listed
Tool C / setup speed: 2 -- self-serve but heavier configuration
Sensitivity:
- raise "predictable cost" above "automation" and Tool C may pass Tool B
- Tool B leads only while its unknown cost is assumed acceptable
Recommendation: PROVISIONAL -- Tool B, contingent on confirming its cost
and email integration. Not a final decision.
NEXT: you approve or change the weights, confirm Tool B's cost and
integration, and make the call. The matrix showed the trade-off in the
open -- it didn't decide it, and NewPrompt didn't score or validate a cell.Where this fits in NewPrompt
A decision matrix is one way to think a choice through in the open, and NewPrompt gives you the structure for it, not the decision. The Markdown Output Builder builds the prompt that returns the matrix in a fixed shape — the scoring table plus the criteria, weights, unknowns, and sensitivity sections around it — so the output is inspectable instead of a paragraph. The Product Manager Role Prompt lends a decision-experienced lens for choosing and weighting criteria against impact, effort, and risk, and the Product Validation Decision Framework Prompt — though it's scoped to product validation, not general decisions — is worth borrowing for one habit the matrix needs at the end: commit to a single call, then read the open risks that could change it. Each builds a prompt you run in your own AI tool.
This guide sits among the decision-support neighbors as the one that builds the full scored table. Getting the AI to compare options and recommend one is the lighter move — a side-by-side and a pick; the matrix adds the weights, the per-cell reasons, and the sensitivity check that make the recommendation reviewable rather than asserted. Classifying whether a decision is reversible is a different question entirely — how hard it is to undo, not which option scores highest — and the two pair well: the reversibility read tells you how much rigor the choice deserves, and the matrix is the rigor. And logging a decision comes after this; the matrix is what you'd attach to that log to show how the call was reached.
A decision matrix is the arithmetic written out under a hard call, not the call itself. Anyone can announce "Tool B" — the matrix is what shows the number came from cost weighted this much, setup weighted that much, and two cells still marked unknown. Its job isn't to hand you a winner; it's to turn the argument about the winner into a specific one — "I'd weight cost higher," "that score assumes a demo we never ran" — instead of a standoff of opinions. The AI can lay that arithmetic out fast and legibly; which criteria matter, what they're worth, and whether the top score survives your own weights is the reading you make, and the call you own.