home / skills / coowoolf / insighthunt-skills / opportunity-cost-minimization
This skill helps you minimize opportunity cost during quarterly planning by prioritizing strategic bets over quick wins to maximize long-term impact.
npx playbooks add skill coowoolf/insighthunt-skills --skill opportunity-cost-minimizationReview the files below or copy the command above to add this skill to your agents.
---
name: Opportunity Cost Minimization
description: Stop optimizing for positive ROI and start focusing on minimizing opportunity cost—choosing the BEST possible use of time, not just a good one. Use during quarterly planning and roadmap prioritization.
---
# Opportunity Cost Minimization
> "You should stop doing work that simply provides a positive return on investment and start focusing on work that minimizes opportunity cost." — Shreyas Doshi
## What It Is
In high-leverage roles, there are infinite tasks with positive ROI. Focusing on ROI leads to picking small, quick wins. Instead, focus on **minimizing opportunity cost**—choosing the *best* possible use of time, not just a *good* one.
## When To Use
- **Quarterly planning** and roadmap prioritization
- When team keeps filling roadmaps with **"low-hanging fruit"**
- When strategic bets are being neglected for quick wins
- To break the cycle of **incrementalism**
## The Problem with ROI
```
Impact
ROI = ─────────
Time
The formula incentivizes:
❌ Quick, small things (reduce denominator)
❌ Easy wins that don't compound
❌ Avoiding hard, high-impact work
```
## Core Principles
### 1. The ROI Trap
ROI formula incentivizes doing quick, small things rather than hard, big things.
### 2. Define Allocation Buckets
Use a framework like:
- **60%** Incremental improvements
- **30%** Big bets / strategic investments
- **10%** Infrastructure / technical debt
### 3. The Right Question
Ask: **"Is this the optimal use of time?"**
NOT: **"Is this a good use of time?"**
## How To Apply
```
STEP 1: List All Candidate Projects
STEP 2: Calculate Naive ROI
└── "Quick win: 2x return in 2 weeks = 1.0 ROI"
└── "Strategic bet: 10x return in 6 months = 0.83 ROI"
STEP 3: Ask Opportunity Cost Question
└── "If we do the quick win, we WON'T do the strategic bet"
└── "What's the cost of NOT doing the strategic bet?"
STEP 4: Evaluate 2-Year Impact
└── Quick wins: Often forgotten
└── Strategic bets: Compound over time
STEP 5: Force Allocation
└── Mandate X% of roadmap = strategic bets
└── Don't let quick wins consume 100%
```
## Common Mistakes
❌ Prioritizing "quick wins" because they're easy to justify
❌ Measuring team output by number of shipped features
❌ Neglecting difficult strategic bets that require longer timelines
## Real-World Example
At Stripe, Shreyas shifted focus from small incremental fixes (positive ROI) to a massive, scary refactor of marketplace payments (Connect) because the opportunity cost of not doing it was huge.
---
*Source: Shreyas Doshi, Lenny's Podcast*
This skill reframes prioritization from chasing positive ROI to minimizing opportunity cost—picking the single best use of scarce time and resources rather than any activity with a positive return. It’s designed for product leaders and teams during quarterly planning and roadmap setting to avoid incrementalism and invest in compounding, high-impact work.
The skill inspects candidate projects against both naive ROI and the opportunity cost of not doing alternatives. It asks teams to list projects, compute short-term ROI, then compare two-year impacts and what gets forgone if a quick win is chosen. Finally, it enforces allocation buckets so strategic bets can’t be crowded out by easy wins.
How do I convince stakeholders who want quick wins?
Show the two-year impact comparison and quantify what will be impossible to do if capacity is spent on quick wins. Use allocation buckets to guarantee strategic capacity.
What if strategic bets look risky and uncertain?
Treat uncertainty explicitly: scope experiments to reduce key risks, set measurable milestones, and protect runway. The point is to balance risk with forced allocation, not to ignore validation.