making-product-decisions

Framework for structured product decision-making. Use when facing complex tradeoffs, aligning stakeholders, documenting decisions, or choosing between multiple valid approaches.

210 stars

Best use case

making-product-decisions is best used when you need a repeatable AI agent workflow instead of a one-off prompt.

Framework for structured product decision-making. Use when facing complex tradeoffs, aligning stakeholders, documenting decisions, or choosing between multiple valid approaches.

Teams using making-product-decisions should expect a more consistent output, faster repeated execution, less prompt rewriting.

When to use this skill

  • You want a reusable workflow that can be run more than once with consistent structure.

When not to use this skill

  • You only need a quick one-off answer and do not need a reusable workflow.
  • You cannot install or maintain the underlying files, dependencies, or repository context.

Installation

Claude Code / Cursor / Codex

$curl -o ~/.claude/skills/making-product-decisions/SKILL.md --create-dirs "https://raw.githubusercontent.com/flpbalada/my-opencode-config/main/skills/making-product-decisions/SKILL.md"

Manual Installation

  1. Download SKILL.md from GitHub
  2. Place it in .claude/skills/making-product-decisions/SKILL.md inside your project
  3. Restart your AI agent — it will auto-discover the skill

How making-product-decisions Compares

Feature / Agentmaking-product-decisionsStandard Approach
Platform SupportNot specifiedLimited / Varies
Context Awareness High Baseline
Installation ComplexityUnknownN/A

Frequently Asked Questions

What does this skill do?

Framework for structured product decision-making. Use when facing complex tradeoffs, aligning stakeholders, documenting decisions, or choosing between multiple valid approaches.

Where can I find the source code?

You can find the source code on GitHub using the link provided at the top of the page.

Related Guides

SKILL.md Source

# Making Product Decisions - Structured Decision Framework

A meta-framework for making and documenting product decisions. Combines decision
science principles with practical product management needs to ensure better
decisions, stakeholder alignment, and organizational learning.

## When to Use This Skill

- Choosing between competing priorities or approaches
- Making irreversible or high-stakes decisions
- Aligning stakeholders with different perspectives
- Documenting decisions for future reference
- Evaluating past decisions for learning
- Delegating decision-making authority

## Core Concepts

### Decision Types (Bezos Framework)

```
+------------------+------------------+
|   Type 1         |   Type 2         |
|   (One-way door) |   (Two-way door) |
+------------------+------------------+
| Irreversible     | Reversible       |
| High stakes      | Lower stakes     |
| Slow, careful    | Fast, iterate    |
| Senior decision  | Delegate widely  |
+------------------+------------------+
```

### Decision Quality vs. Outcome

|                   | Good Outcome     | Bad Outcome      |
| ----------------- | ---------------- | ---------------- |
| **Good Decision** | Deserved success | Bad luck         |
| **Bad Decision**  | Good luck        | Deserved failure |

Judge decisions by process quality, not just outcomes.

### Data-Informed vs. Data-Driven

| Approach          | When to Use                                        |
| ----------------- | -------------------------------------------------- |
| **Data-driven**   | Clear metrics, sufficient data, understood system  |
| **Data-informed** | Incomplete data, novel situations, judgment needed |
| **Intuition-led** | Time pressure, expert domain, pattern matching     |

Most product decisions should be data-informed, not purely data-driven.

## Analysis Framework

### Step 1: Frame the Decision

| Element           | Question                       |
| ----------------- | ------------------------------ |
| **What**          | What exactly are we deciding?  |
| **Why**           | Why does this decision matter? |
| **Who**           | Who should be involved?        |
| **When**          | When must we decide by?        |
| **Reversibility** | Type 1 or Type 2 door?         |

### Step 2: Generate Options

Always have at least 3 options:

1. Do nothing / status quo
2. Option A
3. Option B

Avoid binary framing - it limits thinking.

### Step 3: Establish Criteria

| Criterion     | Weight | Why It Matters |
| ------------- | ------ | -------------- |
| [Criterion 1] | [1-5]  | [Explanation]  |
| [Criterion 2] | [1-5]  | [Explanation]  |
| [Criterion 3] | [1-5]  | [Explanation]  |

### Step 4: Evaluate Options

| Option     | Criterion 1 | Criterion 2 | Criterion 3 | Total |
| ---------- | ----------- | ----------- | ----------- | ----- |
| Status quo | [Score]     | [Score]     | [Score]     | [Sum] |
| Option A   | [Score]     | [Score]     | [Score]     | [Sum] |
| Option B   | [Score]     | [Score]     | [Score]     | [Sum] |

### Step 5: Document and Decide

Record:

- Decision made
- Rationale
- Dissenting views
- Success criteria
- Review date

## Output Template

```markdown
## Product Decision Record

**Decision:** [Clear statement of what was decided] **Date:** [Date] **Decision
maker:** [Name] **Status:** [Proposed/Approved/Implemented]

### Context

**Problem/Opportunity:** [What prompted this decision]

**Constraints:** [Time, resources, dependencies]

**Reversibility:** [Type 1 / Type 2]

### Options Considered

| Option     | Description | Pros | Cons |
| ---------- | ----------- | ---- | ---- |
| Status quo | [Desc]      | [+]  | [-]  |
| Option A   | [Desc]      | [+]  | [-]  |
| Option B   | [Desc]      | [+]  | [-]  |

### Decision Criteria

| Criterion | Weight | Rationale |
| --------- | ------ | --------- |
| [C1]      | [1-5]  | [Why]     |
| [C2]      | [1-5]  | [Why]     |

### Evaluation

| Option  | [C1]  | [C2]  | Weighted Total |
| ------- | ----- | ----- | -------------- |
| [Opt 1] | [x/5] | [x/5] | [Score]        |
| [Opt 2] | [x/5] | [x/5] | [Score]        |

### Decision

**Chosen option:** [Option name]

**Rationale:** [Why this option best meets criteria]

**Dissenting views:** [Captured disagreements and concerns]

### Success Criteria

| Metric | Current | Target  | Measure By |
| ------ | ------- | ------- | ---------- |
| [M1]   | [Value] | [Value] | [Date]     |

### Review

**Review date:** [Date] **What we'll evaluate:** [Criteria for success/failure]
```

## Real-World Examples

### Example 1: Build vs. Buy

**Decision**: Build custom analytics or use third-party tool?

| Criterion          | Weight | Build | Buy |
| ------------------ | ------ | ----- | --- |
| Time to market     | 5      | 2     | 5   |
| Customization      | 3      | 5     | 2   |
| Long-term cost     | 4      | 3     | 4   |
| Maintenance burden | 4      | 2     | 5   |
| **Total**          |        | 42    | 66  |

Decision: Buy, despite customization limitations.

### Example 2: Feature Prioritization

**Decision**: Next quarter focus - mobile app or API improvements?

Applied decision criteria:

- Revenue impact (weight: 5)
- User retention (weight: 4)
- Strategic positioning (weight: 3)
- Engineering complexity (weight: 2)

Result: Mobile app scored higher on revenue and retention despite higher
complexity.

## Best Practices

### Do

- Make decision criteria explicit before evaluating
- Include "do nothing" as an option
- Document dissenting opinions
- Set review dates for major decisions
- Separate decision quality from outcome

### Avoid

- Analysis paralysis on Type 2 decisions
- HiPPO (Highest Paid Person's Opinion) decisions
- Retroactive justification
- Ignoring intuition entirely
- Forgetting to review past decisions

### Decision Speed Guidelines

| Type                | Approach                                |
| ------------------- | --------------------------------------- |
| Type 1, high stakes | Take time, involve stakeholders         |
| Type 2, reversible  | Decide quickly, iterate                 |
| Unclear type        | Default to faster, can always slow down |

## Integration with Other Methods

| Method              | Combined Use                    |
| ------------------- | ------------------------------- |
| **Hypothesis Tree** | Structure analysis of options   |
| **Jobs-to-be-Done** | Ground criteria in user needs   |
| **Five Whys**       | Understand decision root causes |

## Resources

- [Thinking in Bets - Annie Duke](https://www.amazon.com/Thinking-Bets-Making-Smarter-Decisions/dp/0735216355)
- [Decisive - Chip & Dan Heath](https://www.amazon.com/Decisive-Make-Better-Choices-Life/dp/0307956393)

Related Skills

what-not-to-do-as-product-manager

210
from flpbalada/my-opencode-config

Anti-patterns and mistakes to avoid as a product manager. Use when evaluating leadership behaviors, improving team dynamics, reflecting on management practices, or onboarding new product managers.

visual-cues-cta-psychology

210
from flpbalada/my-opencode-config

Design effective CTAs using visual attention and gaze psychology principles. Use when designing landing pages, button hierarchies, conversion elements, or optimizing user attention flow through interfaces.

vercel-sandbox

210
from flpbalada/my-opencode-config

Run agent-browser + Chrome inside Vercel Sandbox microVMs for browser automation from any Vercel-deployed app. Use when the user needs browser automation in a Vercel app (Next.js, SvelteKit, Nuxt, Remix, Astro, etc.), wants to run headless Chrome without binary size limits, needs persistent browser sessions across commands, or wants ephemeral isolated browser environments. Triggers include "Vercel Sandbox browser", "microVM Chrome", "agent-browser in sandbox", "browser automation on Vercel", or any task requiring Chrome in a Vercel Sandbox.

value-realization

210
from flpbalada/my-opencode-config

Analyze if end users discover clear value. Use when evaluating product concepts, analyzing adoption, or uncertain about direction.

user-story-fundamentals

210
from flpbalada/my-opencode-config

Capture requirements from user perspective with structured user stories. Use when writing backlog items, defining acceptance criteria, prioritizing features, or communicating requirements between product and development.

typescript-satisfies-operator

210
from flpbalada/my-opencode-config

Guides proper usage of TypeScript's satisfies operator vs type annotations. Use this skill when deciding between type annotations (colon) and satisfies, validating object shapes while preserving literal types, or troubleshooting type inference issues.

typescript-interface-vs-type

210
from flpbalada/my-opencode-config

Guides when to use interface vs type in TypeScript. Use this skill when defining object types, extending types, or choosing between interface and type aliases.

typescript-best-practices

210
from flpbalada/my-opencode-config

Guides TypeScript best practices for type safety, code organization, and maintainability. Use this skill when configuring TypeScript projects, deciding on typing strategies, writing async code, or reviewing TypeScript code quality.

typescript-advanced-types

210
from flpbalada/my-opencode-config

Master TypeScript's advanced type system including generics, conditional types, mapped types, template literals, and utility types for building type-safe applications. Use when implementing complex type logic, creating reusable type utilities, or ensuring compile-time type safety in TypeScript projects.

trust-psychology

210
from flpbalada/my-opencode-config

Build trust signals that reduce perceived risk and enable user action. Use when designing landing pages, checkout flows, onboarding experiences, or any conversion point where user hesitation is a barrier.

theme-epic-story

210
from flpbalada/my-opencode-config

Structure product work hierarchically using themes, epics, and stories. Use when organizing backlogs, planning releases, communicating with stakeholders, or breaking down large initiatives into manageable work.

tailwind-v4-configuration

210
from flpbalada/my-opencode-config

Configure Tailwind CSS v4 with CSS-first approach. Use when installing, migrating from v3, setting up build tools (Vite/PostCSS/CLI), customizing themes with @theme, or configuring plugins.