analyzing-deeply

What this skill does

# Analyzing Problems Deeply

You are activating deep analysis capabilities. Your role is to systematically explore complex problems before rushing to solutions.

## When to Activate

This skill activates when:

- User says "I'm not sure...", "I'm confused...", "Help me think through..."
- Problem statement is ambiguous or unclear
- Multiple competing approaches exist
- High-stakes decision with significant consequences
- Contradictory requirements or constraints
- Previous attempts at solving failed
- Need to understand problem deeply before implementing

## Philosophy

### Why Deep Analysis?

- **Premature Solutions**: Rushing to code often solves wrong problem
- **Hidden Complexity**: Surface-level understanding misses critical factors
- **False Assumptions**: Unchallenged assumptions lead to wrong paths
- **Missed Opportunities**: Deeper analysis reveals better solutions

### When NOT to Use

- Problem is well-defined and straightforward
- Solution is obvious and simple
- Time pressure requires quick action
- Problem has been deeply analyzed already
- Analysis paralysis risk (over-thinking simple problems)

## Analysis Process

### 1. Problem Clarification

Start by ensuring you understand the actual problem:

```markdown
## Initial Understanding

**As Stated**: [User's original request]

**My Interpretation**: [What I think they're asking]

**Questions Before Proceeding**:

1. [Clarifying question 1]
2. [Clarifying question 2]
3. [Clarifying question 3]

[Wait for user response before deep analysis]
```

### 2. Problem Decomposition

Break problem into analyzable components:

```markdown
## Problem Structure

**Core Problem**: [One sentence essence]

**Related Subproblems**:

1. Subproblem A: [Description]
2. Subproblem B: [Description]
3. Subproblem C: [Description]

**Dependencies**: [What depends on what]

**Constraints**:

- Technical: [Technical limitations]
- Business: [Business requirements]
- Resource: [Time, budget, people]
- External: [Third-party dependencies]

**Success Criteria**: [How do we know it's solved?]
```

### 3. Multi-Perspective Analysis

Examine from different angles:

#### Perspective 1: User/Customer

- What problem are they trying to solve?
- What outcome do they actually need?
- What's their mental model?
- What are their pain points?

#### Perspective 2: Technical

- What are the technical constraints?
- What are the implementation challenges?
- What are the performance requirements?
- What are the scalability needs?

#### Perspective 3: Business

- What's the ROI?
- What's the opportunity cost?
- What's the risk?
- What's the timeline?

#### Perspective 4: Maintenance

- Who will maintain this?
- How complex is it?
- What's the bus factor?
- What happens when requirements change?

### 4. Assumption Surfacing

Challenge hidden assumptions:

```markdown
## Assumptions to Validate

**Stated Assumptions**:

- [Assumption 1]: [Why we believe it]
- [Assumption 2]: [Why we believe it]

**Unstated Assumptions** (discovered):

- [Hidden assumption 1]: [Impact if wrong]
- [Hidden assumption 2]: [Impact if wrong]

**Critical to Verify**:

- [Most risky assumption]: [How to validate]
```

### 5. Option Generation

Explore solution space:

```markdown
## Solution Options

### Option 1: [Name]

**Approach**: [How it works]
**Pros**: [Advantages]
**Cons**: [Disadvantages]
**Risks**: [What could go wrong]
**Effort**: [High/Medium/Low]
**Impact**: [High/Medium/Low]

### Option 2: [Name]

[Same structure]

### Option 3: [Name]

[Same structure]

### Option 0: Do Nothing

**Consequences**: [What happens if we don't solve this]
**Is this viable?**: [Yes/No + reasoning]
```

### 6. Tradeoff Analysis

Compare options systematically:

```markdown
## Tradeoff Matrix

| Dimension         | Option 1 | Option 2 | Option 3 |
| ----------------- | -------- | -------- | -------- |
| Complexity        | Low      | Medium   | High     |
| Performance       | Medium   | High     | High     |
| Maintainability   | High     | Medium   | Low      |
| Time to Implement | 2 weeks  | 4 weeks  | 8 weeks  |
| Risk              | Low      | Medium   | High     |
| Scalability       | Medium   | High     | High     |

## Key Tradeoffs

**Speed vs Quality**: [Analysis]
**Complexity vs Flexibility**: [Analysis]
**Cost vs Capability**: [Analysis]
**Short-term vs Long-term**: [Analysis]
```

### 7. Risk Assessment

Identify and analyze risks:

```markdown
## Risk Analysis

### Risk 1: [Name]

- **Probability**: High/Medium/Low
- **Impact**: High/Medium/Low
- **Mitigation**: [How to reduce risk]
- **Contingency**: [What if risk occurs]

### Risk 2: [Name]

[Same structure]

**Highest Priority Risks**:

1. [Most critical risk to address]
2. [Second most critical]
```

### 8. Recommendation

Synthesize analysis into clear recommendation:

```markdown
## Recommendation

**Proposed Approach**: [Clear choice]

**Rationale**:

1. [Reason 1 with supporting analysis]
2. [Reason 2 with supporting analysis]
3. [Reason 3 with supporting analysis]

**This Approach**:

- Solves: [What it addresses]
- Accepts: [Tradeoffs we're making]
- Risks: [Risks we're taking]
- Mitigates: [How we reduce risk]

**Implementation Path**:

1. [First step]
2. [Second step]
3. [Third step]

**Decision Points**:

- [Checkpoint 1]: [What to validate]
- [Checkpoint 2]: [What to validate]

**Reversibility**: [Can we change our mind later? How?]
```

## Analysis Dimensions

### Technical Dimension

- Feasibility and implementation complexity
- Performance and scalability characteristics
- Technology stack and dependencies
- Integration points and interfaces
- Testing and quality assurance needs

### Business Dimension

- Value delivered vs effort required
- Opportunity cost of alternatives
- Timeline and resource requirements
- ROI and business impact
- Market and competitive factors

### User Dimension

- User needs and pain points
- User experience and usability
- Adoption and change management
- Accessibility and inclusivity
- Support and documentation needs

### Organizational Dimension

- Team capabilities and skills
- Organizational priorities and politics
- Existing systems and processes
- Change resistance and culture
- Long-term maintenance and ownership

## Thinking Tools

### First Principles Thinking

Break down to fundamental truths:

1. What do we know for certain?
2. What are we assuming?
3. Can we rebuild from first principles?
4. What's actually required vs nice-to-have?

### Inversion

Think backwards:

1. How could this fail spectacularly?
2. What would make this impossible?
3. If we wanted the opposite outcome, what would we do?
4. What are we trying to avoid?

### Second-Order Effects

Look beyond immediate consequences:

1. If we do X, what happens?
2. Then what happens after that?
3. What are the ripple effects?
4. What changes in the system?

### Pre-Mortem

Imagine failure:

1. It's 6 months later, project failed. Why?
2. What warning signs did we miss?
3. What assumptions were wrong?
4. What could we have done differently?

### Opportunity Cost

What are we giving up:

1. If we do this, what can't we do?
2. What else could we do with these resources?
3. What's the next best alternative?
4. Is this the highest value use of time?

## Integration Points

### Invokes

- **Architect Agent**: For design implications
- **WebSearch**: For external validation
- **/ultrathink**: For even deeper structured analysis

### Escalates To

- **/ultrathink**: When analysis needs extreme depth (30+ min)
- **/consensus**: When multiple stakeholders need alignment
- **/debate**: When competing viewpoints need exploration
- **Architecting Solutions**: Once problem is understood, design solution

### References

- **Decision Frameworks**: `Specs/DecisionFrameworks.md`
- **Analysis Templates**: `Templates/ProblemAnalysis.md`

## Output Format

Structure analysis as:

```markdown
# Deep Analysis: [Problem Name]

## Problem Understanding

[Clarified problem statement]

## Problem Decomposition

[