---
name: skill-decision-support
description: "Present options with trade-offs for informed decision-making — use when choosing between approaches"
disable-model-invocation: true
---

> **Host: Codex CLI** — This skill was designed for Claude Code and adapted for Codex.
> Cross-reference commands use installed skill names in Codex rather than `/octo:*` slash commands.
> Use the active Codex shell and subagent tools. Do not claim a provider, model, or host subagent is available until the current session exposes it.
> For host tool equivalents, see `skills/blocks/codex-host-adapter.md`.


# Decision Support & Options Presentation

## Overview

Structured approach to presenting options and alternatives with clear trade-offs, enabling informed decision-making.

**Core principle:** Understand context → Generate options → Analyze trade-offs → Present clearly → Support choice.


## When to Use

**Use this skill when user:**
- Asks for options or alternatives
- Says "fix or provide options"
- Needs help deciding between approaches
- Wants to see different ways to solve a problem
- Is uncertain about best path forward

**Do NOT use for:**
- General research ("what is X?") → use flow-probe
- Implementation work → use flow-tangle
- Simple yes/no questions
- Already-decided approaches


## The Process

### Phase 1: Context Understanding

#### Step 1: Understand the Decision Point

```markdown
**Decision Context:**

What needs to be decided: [the core question]
Why it matters: [impact of this decision]
Constraints: [time, resources, compatibility, etc.]
Current state: [what exists now]
```

#### Step 2: Gather Requirements

Use AskUserQuestion if needed to understand:
- Must-have requirements
- Nice-to-have features
- Deal-breakers
- Timeline constraints
- Budget/resource constraints


### Phase 2: Generate Options

#### Step 1: Identify Viable Approaches

Generate 2-4 distinct options (not just variations):

| Option Type | When to Include |
|-------------|-----------------|
| **Conservative** | Low risk, proven approach |
| **Moderate** | Balanced risk/reward |
| **Innovative** | Higher risk, potentially better outcome |
| **Minimal** | Simplest possible solution |

**Don't generate options that:**
- Violate stated constraints
- Are clearly inferior to others
- Are essentially the same with minor tweaks

#### Step 2: Research Each Option

For each option, understand:
- How it works
- What it requires
- What the outcome looks like
- What could go wrong


### Phase 3: Trade-off Analysis

For each option, analyze:

```markdown
### Option N: [Name]

**Description:**
[1-2 sentence description]

**Pros:**
- ✅ [Advantage 1]
- ✅ [Advantage 2]
- ✅ [Advantage 3]

**Cons:**
- ❌ [Disadvantage 1]
- ❌ [Disadvantage 2]
- ❌ [Disadvantage 3]

**Effort:** [Low/Medium/High]
**Risk:** [Low/Medium/High]
**Reversibility:** [Easy/Moderate/Difficult to undo]

**Best for:** [when this option makes sense]
```


### Phase 4: Present Options

#### Format for Presentation

```markdown
# Decision: [What needs to be decided]

**Context:** [Brief summary of why this decision is needed]


## Option 1: [Conservative/Proven Approach] ⭐ (Recommended)

**What it is:**
[Clear explanation in 1-2 sentences]

**Pros:**
- ✅ [Pro 1]
- ✅ [Pro 2]
- ✅ [Pro 3]

**Cons:**
- ❌ [Con 1]
- ❌ [Con 2]

**Implementation:**
[Brief overview of what's involved]

**Timeline:** [estimate]
**Risk Level:** Low/Medium/High


## Option 2: [Alternative Approach]

[Same structure as Option 1]


## Option 3: [Another Alternative]

[Same structure as Option 1]


## Recommendation

**I recommend Option [N]: [Name]**

**Why:**
1. [Reason 1]
2. [Reason 2]
3. [Reason 3]

**This option is best because:** [summary of key advantage relative to context]


## Quick Comparison

| Criteria | Option 1 | Option 2 | Option 3 |
|----------|----------|----------|----------|
| Effort | [level] | [level] | [level] |
| Risk | [level] | [level] | [level] |
| Reversible | [yes/no] | [yes/no] | [yes/no] |
| Timeline | [time] | [time] | [time] |
| Best for | [scenario] | [scenario] | [scenario] |


**Which option would you like to proceed with?**
```

#### Guidelines for Presentation

1. **Mark recommendation clearly** with ⭐ or "(Recommended)"
2. **Limit to 2-4 options** (too many = decision paralysis)
3. **Be honest about cons** (don't oversell any option)
4. **Make comparison easy** (use consistent structure)
5. **Support with reasoning** (explain why recommendation makes sense)


### Phase 5: Support the Choice

After user chooses:

```markdown
✅ **Proceeding with Option [N]: [Name]**

**Next steps:**
1. [Step 1]
2. [Step 2]
3. [Step 3]

**I'll now [begin implementation / gather more details / create plan].**
```

If user asks for more info on a specific option:

```markdown
**Deep dive on Option [N]:**

**How it works:**
[Detailed explanation]

**Implementation steps:**
1. [Detailed step 1]
2. [Detailed step 2]
...

**Potential issues and mitigations:**
- Issue: [potential problem]
  Mitigation: [how to handle it]

**Would you like to proceed with this option?**
```


## Common Patterns

### Pattern 1: "Fix or Provide Options"

```
User: "The auth system is broken. Fix or provide options."

Response structure:
1. Assess: Is the fix obvious or are there choices?
2. If obvious: Present the fix + ask for confirmation
3. If choices: Present options with trade-offs

Example:

I can see the auth issue. Here are your options:

**Option 1: Quick Fix** (Recommended for immediate deployment)
- Patch the current JWT validation
- Pros: Fast, low risk
- Cons: Doesn't address underlying architecture

**Option 2: Comprehensive Refactor**
- Rebuild auth with better patterns
- Pros: Long-term solution
- Cons: Takes longer, more testing needed

**Which approach fits your timeline?**
```

### Pattern 2: "What Are My Options"

```
User: "I need to add caching. What are my options?"

Response structure:
1. Understand requirements (what needs caching, scale, etc.)
2. Generate 3-4 caching options
3. Present with trade-offs
4. Recommend based on their context

Example:

For caching your API responses, here are the main options:

**Option 1: In-Memory Cache (Node-cache)** ⭐
- Best for: Single-server setup
- Pros: Simple, fast, no external dependencies
- Cons: Lost on restart, doesn't scale across servers

**Option 2: Redis**
- Best for: Multi-server or persistence needed
- Pros: Persistent, distributed, feature-rich
- Cons: Requires Redis server, more complex

**Option 3: CDN Caching (Cloudflare/Fastly)**
- Best for: Static/semi-static content
- Pros: Global distribution, handles scale
- Cons: Less control, costs, public content only

**Based on your single-server setup, Option 1 is recommended.**
Which would you like to use?
```

### Pattern 3: "Help Me Decide"

```
User: "Should I use TypeScript or stick with JavaScript? Help me decide."

Response structure:
1. Clarify decision factors (team size, project scope, timeline)
2. Present structured comparison
3. Make recommendation based on their specific context
4. Support whatever they choose

Example:

Let me help you decide between TypeScript and JavaScript.

**TypeScript:**
Pros: Type safety, better tooling, catches errors early
Cons: Learning curve, build step, more setup
Best for: Larger teams, long-term projects, complex domains

**JavaScript:**
Pros: Simpler, no build step, familiar to all devs
Cons: Runtime errors, less IDE support, harder to refactor
Best for: Small projects, prototypes, simple applications

**For your [context]:** I recommend TypeScript because [reason].

Would you like to proceed with TypeScript, or would JavaScript be better for your needs?
```


## Integration with Other Skills

### With flow-probe

```
Need to research options thoroughly?
→ Use flow-probe to gather information
→ Use skill-decision-support to present findings as options
```

### With flow-tangle

```
User chose an option?
→ Use flow-tangle to implement the chosen approach
```

### With skill-debug

```
Bug could be fixed multiple ways?
→ Use skill-decision-support to present fix options
→ Use skill-debug to implement chosen fix systematically
```


## Best Practices

### 1. Tailor to User's Needs

**Ask about constraints:**
```markdown
Before presenting options, I need to understand:
- Timeline: How urgent is this?
- Resources: What's available (team size, budget, infrastructure)?
- Risk tolerance: Is this production-critical or experimental?
- Reversibility: Must this decision be reversible?
```

### 2. Quantify When Possible

**Good:**
```
**Timeline:**
- Option 1: 2-3 hours
- Option 2: 1-2 days
- Option 3: 1 week
```

**Poor:**
```
**Timeline:**
- Option 1: Quick
- Option 2: A while
- Option 3: Longer
```

### 3. Be Honest About Unknowns

```
**Option 2: Microservices Architecture**

⚠️ **Unknown:** Migration effort could be 2-4 weeks depending on current coupling.
Would need to audit codebase to give accurate estimate.
```

### 4. Provide "Escape Hatch"

Always include:
```
**Not satisfied with these options?**

I can also:
- Research more alternatives
- Combine aspects of multiple options
- Deep-dive on any specific approach
- Prototype a solution to test viability
```


## Red Flags - Don't Do This

| Action | Why It's Wrong |
|--------|----------------|
| Only present one "option" | That's not a choice |
| Present 8+ options | Decision paralysis |
| Hide significant cons | User can't make informed choice |
| Recommend without reasoning | User can't evaluate recommendation |
| Ignore stated constraints | Wasting user's time |
| Present obviously bad options as viable | Undermines trust |


## Quick Reference

| User Request | Action |
|--------------|--------|
| "fix or provide options" | Assess if fix obvious → If yes: present fix, if no: present options |
| "what are my options" | Understand context → Generate 2-4 options → Present with trade-offs |
| "help me decide" | Clarify decision factors → Compare approaches → Recommend with reasoning |
| "show alternatives" | Generate alternatives → Analyze pros/cons → Present structured comparison |


## The Bottom Line

```
Decision support → Clear options + Honest trade-offs + Reasoned recommendation
Otherwise → Confusion + Poor decisions + Regret
```

**Understand context. Present real choices. Support with reasoning. Respect their decision.**