Ask a language model to score a backlog and it will. Every item, all four RICE dimensions, confident numbers, plausible reasoning, in about eight seconds. The output looks exactly like the output of a team that spent an afternoon on it.

That resemblance is the problem worth thinking about carefully, because the two artifacts aren't interchangeable and the difference is invisible on the page.

What the model is good at

Three things.

First-pass estimates that break the blank page

Scoring twenty items from zero is tedious enough that teams either skip it or rush it. A draft to react to is easier than a draft to originate, and reacting is where the useful thinking happens — "no, effort is way higher than that, because it touches billing" is a real contribution that the blank page wouldn't have produced.

Surfacing what you left out

Models are good at the move where you describe a feature and something asks about the migration path, the permissions model, the support burden. Not because it knows your system, but because those questions recur across every system and you were thinking about the happy path.

Arguing the other side

Ask for the strongest case against your top-ranked item and you'll usually get something worth answering. This is the least-used and most valuable mode, because it's the one where being unattached to your roadmap is an advantage rather than a limitation.

Notice that all three produce input to a judgement. None produces the judgement.

What it's not good at

The model doesn't know your reach. It cannot: the number lives in your analytics, and if you did not tell it, whatever it produces is a plausible-looking fabrication. Same for effort, which depends on your codebase, your team, and what else is in flight.

More subtly, it doesn't know your strategy — not the sentence in the deck, the real one. The one that says this quarter you're willing to underinvest in retention because the enterprise motion has to land first. That constraint is what makes half of prioritization decisions non-obvious, and it's exactly the sort of thing that lives in a founder's head rather than a document.

A confident score computed from inputs the model invented is a guess wearing the visual signature of rigour — worse than a guess that plainly looks like one.

The line that matters

Forget "AI for the easy parts, humans for the hard parts." The real line is simpler:

The model can produce anything you would be willing to argue with. It should not produce anything you would be tempted to accept without arguing.

A drafted score with visible reasoning invites argument — you read the reasoning, disagree with the effort estimate, and change it. A final ranking with no reasoning invites acceptance, because there's nothing to push against and the number already looks decided.

Reasoning attached to the output is what keeps it a draft instead of a decision — remove it and there's nothing left to push against.

Accountability is the real constraint

Models will keep getting better at estimation, so accuracy won't hold up for long as the reason to keep a person in the loop. The reason that does hold up: prioritization decisions get defended, and you cannot hold a model accountable.

When someone asks why their feature was cut, the answer has to come from somebody who chose it, can explain the tradeoff, and will still be there when it turns out wrong. "The scoring model ranked it fourth" dodges that question rather than answering it. Teams notice when a decision has no author, and the ones who lost the decision notice fastest.

A prioritization system that removes the accountable human just relocates the hard part, from a person who can be argued with to a process that can't.

What this looks like in practice

Concretely, the shape that works:

Model drafts, with reasoning shown. Every suggested score arrives with the sentence that produced it.
Person edits before it counts. Nothing enters the ranking on the model's authority alone.
Grounding beats generality. Feed it your product context and prior decisions; an estimate anchored in what your team actually shipped beats one anchored in the internet's average product team.
The rationale is human. Whatever gets recorded as the reason — see why that record matters — is written by the person accountable for the call, not generated alongside it.

That's the division Tarazu is built around, and it's a deliberate constraint rather than a limitation waiting to be lifted. The AI drafts. A person decides. The interesting part was never the arithmetic.

How it works covers where the AI sits in the loop, including which model does what and what it's given as context.

Let the model draft the score, not make the call