business-case
Build a business case for a build/buy/defer investment decision — do-nothing always included as the baseline, benefits quantified as re-runnable calculations with confidence tags, full costs (build + run + opportunity), ranges instead of false precision, and the flip-assumption named. Use when the user needs to justify an investment, write a business case, compare build vs buy vs defer, or get budget/sponsor approval for an initiative.
Other ways to install
With the sibling skills it hands off to:
The whole pack it belongs to:
By hand, from a clone of the repo:
In Claude Code, with the product-manager plugin installed, invoke it as:
Try it
A realistic prompt from the skill's acceptance evals:
Write the business case for replacing our homegrown support ticket router at Northwind. Today 40 agents each spend about 20 minutes a day manually re-routing misassigned tickets (from a two-week time study). Loaded agent cost is $45/hour. Options on the table: build a ML router (estimate 3 engineers for 2 quarters), buy a vendor tool (Vendor X quoted $60k/year, year-two price unknown), or keep things as they are. The same 3 engineers would otherwise ship the self-serve billing portal. The VP of Support decides by November 15.
What a good result looks like
Example output
build vs. buy a feature-flag system · the skill's own worked example, source
"Should [Acme] build an in-house feature-flag system or buy a SaaS one? ~30 engineers, currently gating releases with config files and redeploys."
The ask
Buy the SaaS feature-flag service (~$18–30k/yr). It pays back in < 3 months against ~$140k of first-year build cost and recurring toil, and frees roadmap capacity now. Decision needed before next quarter's release-velocity commitments.
Options (Option 0 is costed)
| Option | Build (one-time) | Run (yr 1) | Opportunity cost |
|---|---|---|---|
| 0 — Status quo (config + redeploy) | $0 | ~$60–90k/yr toil | Slow releases → est. 1–2 delayed launches/yr |
| 1 — Build in-house | ~$110–160k | ~$25–40k/yr (on-call, maint.) | 2 eng × 3–4 mo off roadmap |
| 2 — Buy SaaS | ~$5k (integrate) | ~$18–30k/yr license | ~1 eng-week integration |
Benefits (re-runnable calculations, sourced, confidence-tagged)
- Toil removed vs. Option 0: each gated release currently costs ~1 eng-hr of redeploy coordination × ~15 releases/mo × $120 loaded/hr = ~$22k/yr recovered. (confidence: medium — release count from deploy logs; hourly is loaded-cost estimate.)
- Incident reduction: flag-based instant rollback vs. redeploy shortens mean remediation from ~40 min to ~5 min; at ~6 rollback-worthy incidents/yr that's ~3.5 hrs × team = ~$8–15k/yr avoided. (confidence: low — incident count is small-sample; range reflects it.)
- Release velocity: decoupling deploy from release plausibly removes 1–2 launch slips/yr; value is real but not costed here (depends on launch revenue) — flagged for the decision owner.
Totals are ranges; the lower end is likelier for the hard-dollar items (toil is the solid number; incident/velocity are directional).
The flip-assumption
The case flips to Build only if flag evaluation must run in a data plane the SaaS can't reach (e.g. strict data-residency or sub-ms in-process evaluation at scale). Confidence that this doesn't apply is medium. De-risking step before committing to Buy: a 1-week spike confirming the SaaS SDK meets latency + residency requirements — cheap insurance against the one assumption that would reverse the decision.
Recommendation
Buy (Option 2). Lowest first-year cost, fastest payback, and it returns ~2 engineers to the roadmap that Build would consume. The runner-up's best argument, stated fairly: Build is genuinely better if flag evaluation becomes a core differentiator or a hard data-residency constraint emerges — in that world the SaaS boundary bites and owning the system is worth the cost. The spike above is what tells us which world we're in.
Why this passes the quality bar
The ask leads in under 40 words; Option 0 is present and costed; every benefit is a calculation with sourced inputs and a confidence tag; outputs are ranges naming the likelier end; all three cost layers appear per option; the flip-assumption is identified with a de-risking step; and the recommendation is singular while stating the runner-up's strongest case honestly.
How it's checked
Measured against plain Claude Code (2026-10-23): it met 81% of its checks, against 55% without it, and a blind judge preferred it. How skills are checked
21 assertions across 3 acceptance evals, and 7 trigger queries. Every skill's checks
What the output must do
When it should and shouldn't activate
Should activate:
- Write the business case for building our own feature-flag service versus buying one
- Should we invest two engineer-quarters in rebuilding search? I need something to take to the sponsor
- Compare build vs buy vs defer for the new data pipeline, with the cost of doing nothing priced
- I need budget approval for an observability overhaul — help me justify the spend
Should leave to another skill:
- The investment's approved — now write the PRD for the ML router
- Pick between Kafka, Kinesis, and Pub/Sub for the approved event bus
- Compress this 12-page business case into a one-page summary for the board
Related skills
Source
SKILL.md · the whole folder on GitHub.