Most idea scorecards average six numbers and call it judgment. MakeOrKillIt runs a knockout gate first, scores in ranges instead of false precision, and argues against your idea before it lets it pass.
No sign-up to run your first idea. Watch it reach a verdict live.
Score everything, take the mean, ship the top quartile — and a single fatal flaw hides behind five healthy numbers. The fix isn't a better average. It's separating what's fatal from what's merely weak.
One number per dimension, averaged into a single verdict. A 9 on market quietly cancels a 1 on legality. False precision, real blind spots.
A binary knockout gate catches the fatal flaw first. Survivors are scored in confidence-weighted ranges, then aggregated by a deterministic rule.
The LLM does the reading and proposing. You correct what it got wrong. The band math and aggregation are deterministic — same input, same review, same verdict.
An LLM pulls structured attributes from your free text — problem, market, model — and never invents numbers. Thin evidence lowers confidence, not honesty.
Five must-meet criteria run as a binary gate. Any clear failure kills the idea before scoring — a fatal flaw can't be averaged away.
Each dimension gets a point, a confidence, and a rationale. Low-confidence scores fall to you for review. You override; the math stays deterministic.
Weighted low and high bounds combine conservatively into a 0–100 range. Correlated uncertainty widens the band — cautious by default.
Two thresholds plus band width map to make / hold / kill. Where the band sits — and how wide it is — is the verdict.
You get the binding constraints dragging the score down, the cheapest experiments to shrink the band, and what would flip the verdict.
Every dimension is a range whose width is set by confidence. Guess a market size instead of reading it, and confidence drops — so the band widens and the verdict leans toward hold. Uncertainty is priced in, not hidden.
Weights sum to one and are the starting point, not the last word: the calibration loop retunes them as real outcomes come in.
Any clear failure is an instant kill. When the evidence is genuinely unclear, the gate doesn't guess — it asks you.
Can it be done lawfully and ethically at all?
Is there a meaningful floor of users to serve?
Is the core build reasonably possible?
Does it fit the stated mission and strategy?
Can you reach the minimum resources required?
For every idea, it writes the strongest case for killing it.
The scoring model runs skeptical. For each dimension it names the single strongest piece of disconfirming evidence, then builds a whole-idea kill case — the most convincing version it can, whether it believes it or not. It's the best defense against talking yourself into your own idea.
The decision comes from where the aggregate band sits relative to the make line (65) and the kill line (40) — and, for everything in between, how wide the band is.
low ≥ 65 — the worst realistic case is still good enough. Build it.
Wide band → reduce uncertainty with cheap evidence. Narrow but middling → reshape or walk.
high ≤ 40— the best realistic case still isn't worth it. Move on.
Every verdict is stored as a prediction. When the real outcome is known, it's recorded and paired back. Once enough outcomes accumulate, weights and thresholds are re-fit against what actually happened — proposed for human approval, versioned so you can roll back. Without this loop it's just an opinion generator; with it, it earns its verdicts.
Paste the problem, the user, and how it makes money. Watch the knockout gate, the bands, and the verdict resolve live.