Evaluating Trade-offs

Scope

• Turning an ambiguous “pros/cons” debate into a decision-ready trade-off evaluation
• Comparing options using all-in cost (not just dollars) and explicit opportunity cost
• Using order-of-magnitude estimates (ranges + confidence) instead of false precision
• Stress-testing decisions with thought experiments (pre-mortems, reversibility, “worse first” dips)
• Avoiding sunk-cost traps with a clean stop/continue decision rule

• “Help me evaluate this trade-off and recommend a path.”
• “Create a pros/cons that actually leads to a decision.”
• “Compare options with cost/impact ranges and key assumptions.”
• “We’re debating speed vs quality—what’s the right trade and how do we manage the dip?”
• “Should we keep investing in this project, or stop? (Sunk cost question.)”

• You need to clarify what problem you’re solving (use

  problem-definition

  ).
• You need a full cross-functional decision process (use

  running-decision-processes

  ).
• You’re prioritizing across many initiatives (use

  prioritizing-roadmap

  ).
• You’re cutting scope to hit a date/timebox (use

  scoping-cutting

  ).
• The decision is personal/legal/HR/financial advice (escalate to qualified humans).

Inputs

• The trade-off / decision statement (one sentence) and a decision date (or “by EOW”)
• 2–4 options you’re choosing between (include “do nothing” if plausible)
• Constraints + non-negotiables (budget, headcount, policy, deadlines, customer commitments)
• What “good” means (success metrics + guardrails) and the time horizon you care about
• What you already know (evidence) + biggest unknowns (assumptions that drive the choice)

• Ask up to 5 questions from references/INTAKE.md (3–5 at a time).
• If inputs are unavailable, proceed with explicit assumptions and label unknowns that would change the recommendation.

Outputs (deliverables)

1. Trade-off brief (decision, why now, options, constraints, horizon, stakeholders)
2. Options + criteria matrix (criteria + weights/guardrails; option notes)
3. All-in cost + opportunity cost table (money, people/time, eng effort, complexity, displacement)
4. Impact ranges (order-of-magnitude) (upside/downside ranges, confidence, key assumptions)
5. Worse-first + mitigation plan (expected dip, leading indicators, mitigations, comms)
6. Recommendation + stop/continue triggers (decision, rationale, review date, kill/continue criteria)
7. Risks / Open questions / Next steps (always included)

Workflow (7 steps)

1) Frame the trade-off (make it decidable)

• Inputs: User request; references/INTAKE.md.
• Actions: Write the decision in one sentence (“We are choosing X vs Y by DATE to achieve GOAL”). List constraints/non-negotiables. Confirm the decision owner and who must live with the outcome.
• Outputs: Trade-off brief (decision, why now, constraints, stakeholders).
• Checks: You can answer: “What exactly are we deciding, by when, and for what outcome?”

2) Define what you’re optimizing (criteria + horizon)

• Inputs: Goals, metrics, guardrails; time horizon.
• Actions: Pick 4–8 criteria (include at least one guardrail like trust/reliability/cost). Decide weights only if it changes the decision. Explicitly name what you’re not optimizing for.
• Outputs: Options + criteria matrix (criteria definitions + weights/guardrails).
• Checks: Criteria reflect real trade-offs (not “everything is important”); horizon is explicit (e.g., 90 days vs 2 years).

3) Build the all-in cost + opportunity cost view

• Inputs: Team capacity, budget, dependencies, timelines.
• Actions: Estimate all-in cost (cash, headcount time, eng effort, maintenance, coordination). List the opportunity cost: what won’t be done if you choose each option.
• Outputs: All-in cost + opportunity cost table.
• Checks: Costs include “hidden” items (maintenance/on-call, tooling, cross-team coordination, switching costs).

4) Estimate impact with ranges (avoid false precision)

• Inputs: Any baseline numbers; evidence; assumptions.
• Actions: For each option, estimate upside/downside as ranges and note confidence. Prefer order-of-magnitude comparisons (10× vs 1.1×). Identify the 2–3 assumptions that drive the model.
• Outputs: Impact ranges table (range, confidence, key assumptions).
• Checks: No fake decimals; uncertainty is explicit; the decision is driven by a few key drivers you can name.

5) Run “thought experiments” (think more, build less)

• Inputs: Options, assumptions, risks.
• Actions: Do a pre-mortem for the top 1–2 options (“It failed—why?”). Identify the cheapest evidence to de-risk the biggest assumption (data pull, customer calls, small prototype, timeboxed spike). Decide if this should be a thought experiment only (no build) vs a real experiment.
• Outputs: Assumption list + minimal validation plan (if needed).
• Checks: Proposed tests are the smallest that could change your mind; you’re not shipping an “obvious loser” experiment.

6) Account for “worse first” + sunk costs

• Inputs: Expected short-term impacts; current investment/sunk costs.
• Actions: Name any “worse-first” dip (short-term pain) and plan mitigations/leading indicators. Apply a sunk-cost reset: “If we weren’t already doing this, would we start today?” Define stop/continue triggers and a review date.
• Outputs: Worse-first plan + stop/continue triggers.
• Checks: The plan anticipates the dip; continuation logic ignores sunk costs and focuses on future ROI and strategic fit.

7) Recommend, commit, and quality-gate

• Inputs: All artifacts above.
• Actions: Write the recommendation with rationale and explicit trade-offs (what you will stop doing). Add risks, open questions, and next steps with owners/dates. Run references/CHECKLISTS.md and score with references/RUBRIC.md.
• Outputs: Final Trade-off Evaluation Pack.
• Checks: A stakeholder can read this async and make (or support) the decision without re-litigating the debate.

Quality gate (required)

• Use references/CHECKLISTS.md and references/RUBRIC.md.
• Always include: Risks, Open questions, Next steps.

Examples