# thinking-frameworks

> Multi-framework ideation engine for comprehensive idea evolution

- Author: z
- Repository: tktk4751/superspec
- Version: 20260127050940
- Stars: 0
- Forks: 0
- Last Updated: 2026-02-06
- Source: https://github.com/tktk4751/superspec
- Web: https://mule.run/skillshub/@@tktk4751/superspec~thinking-frameworks:20260127050940

---

---
name: thinking-frameworks
version: 2.0.0
description: "Multi-framework ideation engine for comprehensive idea evolution"
category: discovery
complexity: advanced
requires-confidence: 80
mcp-servers: [sequential, vibe-check]
related-agents: [evolve-facilitator]
requirements:
  - REQ-EVOLVE-004
  - REQ-EVOLVE-005
test-requirements:
  - TR-SKILL-010
---

# Thinking Frameworks Skill

> Apply multiple creative thinking frameworks to evolve and strengthen ideas systematically.

## When to Use

- Evolving vague ideas into concrete proposals
- Challenging assumptions in existing concepts
- Generating multiple alternative approaches
- Analyzing ideas from multiple perspectives
- Breaking mental constraints and biases

## Supported Frameworks

### 1. SCAMPER (Creative Transformation)

```yaml
framework: scamper
purpose: "Generate variations by systematically modifying existing concepts"
phases:
  - substitute: "What can be substituted?"
  - combine: "What can be combined?"
  - adapt: "What can be adapted from elsewhere?"
  - modify: "What can be modified/magnified/minimized?"
  - put_to_other_uses: "How else can this be used?"
  - eliminate: "What can be removed?"
  - reverse: "What can be reversed/rearranged?"
output_template: framework-outputs/scamper.md
```

### 2. Six Thinking Hats (Parallel Thinking)

```yaml
framework: six_hats
purpose: "Explore idea from six distinct cognitive perspectives"
hats:
  white:
    focus: "Facts and information"
    question: "What data do we have?"
  red:
    focus: "Emotions and intuition"
    question: "What does my gut say?"
  black:
    focus: "Caution and critical thinking"
    question: "What could go wrong?"
  yellow:
    focus: "Optimism and benefits"
    question: "What are the advantages?"
  green:
    focus: "Creativity and alternatives"
    question: "What other possibilities exist?"
  blue:
    focus: "Process and meta-thinking"
    question: "What should we think about next?"
output_template: framework-outputs/six-hats.md
```

### 3. Jobs-to-be-Done (User-Centric Analysis)

```yaml
framework: jtbd
purpose: "Understand the underlying job users are trying to accomplish"
components:
  functional_jobs: "What task needs to be done?"
  emotional_jobs: "How do they want to feel?"
  social_jobs: "How do they want to be perceived?"
  job_map: "What are the process steps?"
  desired_outcomes: "What success looks like?"
outcome_formula: "Minimize/Maximize + [metric] + [contextual clarifier]"
output_template: framework-outputs/jtbd.md
```

### 4. Value Proposition Canvas (Product-Market Fit)

```yaml
framework: vpc
purpose: "Ensure alignment between user needs and product features"
customer_profile:
  jobs: "What users are trying to accomplish"
  pains: "Frustrations, obstacles, risks"
  gains: "Benefits and desired outcomes"
value_map:
  products_services: "What we offer"
  pain_relievers: "How we reduce pain"
  gain_creators: "How we create value"
fit_assessment:
  - problem_solution_fit
  - product_market_fit
output_template: framework-outputs/vpc.md
```

### 5. Systems Thinking (Holistic Analysis)

```yaml
framework: systems_thinking
purpose: "Understand interconnections and emergent behaviors"
components:
  boundaries: "What's inside/outside the system?"
  elements: "What are the key components?"
  interconnections: "How do parts relate?"
  feedback_loops: "What reinforcing/balancing loops exist?"
  delays: "Where are time lags?"
  leverage_points: "Where to intervene effectively?"
output_template: |
  ## System Map
  - Boundaries: [system boundaries]
  - Key Elements: [list of components]
  - Interconnections: [relationships]
  - Feedback Loops: [reinforcing/balancing]
  - Leverage Points: [high-impact interventions]
```

### 6. Design Thinking (Human-Centered Design)

```yaml
framework: design_thinking
purpose: "Create human-centered solutions through empathy and iteration"
phases:
  empathize: "Understand user needs deeply"
  define: "Frame the right problem"
  ideate: "Generate diverse solutions"
  prototype: "Build to think"
  test: "Learn from feedback"
key_questions:
  - "What are users experiencing?"
  - "What's the real problem?"
  - "How might we...?"
output_format: "insights + how_might_we_questions + solution_concepts"
```

### 7. Lateral Thinking (Assumption Busting)

```yaml
framework: lateral_thinking
purpose: "Break free from conventional patterns"
techniques:
  random_entry: "Use random input to trigger new ideas"
  provocation: "Make deliberately provocative statements"
  challenge: "Question why things are done this way"
  analogy: "Apply solutions from other domains"
  reversal: "Consider the opposite"
po_statements:
  - "Po: What if [assumption] were false?"
  - "Po: What if we [opposite action]?"
output: "Challenged assumptions + new possibilities"
```

### 8. Meta Thinking (Cognitive Analysis)

```yaml
framework: meta_thinking
purpose: "Think about the thinking process itself"
dimensions:
  biases: "What cognitive biases might affect us?"
  assumptions: "What are we taking for granted?"
  mental_models: "What frameworks are we using?"
  blind_spots: "What are we not seeing?"
  thinking_style: "How are we approaching this?"
bias_checklist:
  - confirmation_bias
  - anchoring_bias
  - availability_heuristic
  - sunk_cost_fallacy
output: "Identified biases + corrective strategies"
```

### 9. Example Mapping (Behavior Specification)

```yaml
framework: example_mapping
purpose: "Concretize abstract ideas through specific examples"
structure:
  story: "As a [persona], I want [goal], so that [benefit]"
  rules: "Business rules governing behavior"
  examples: "Concrete scenarios illustrating rules"
  questions: "Unresolved ambiguities"
color_coding:
  yellow: "Story (center)"
  blue: "Rules (row headers)"
  green: "Examples (under rules)"
  red: "Questions (anywhere)"
output_template: example-map.md
```

### 10. Socratic Dialogue (Deep Questioning)

```yaml
framework: socratic_dialogue
purpose: "Reveal hidden assumptions through systematic questioning"
question_types:
  clarification: "What do you mean by...?"
  probing_assumptions: "What are we assuming?"
  probing_reasons: "Why do you think that?"
  questioning_viewpoints: "What's an alternative view?"
  probing_implications: "What would follow from that?"
  questioning_the_question: "Why is this important?"
dialogue_protocol: |
  1. Ask open-ended questions
  2. Listen for assumptions
  3. Challenge gently
  4. Seek underlying reasons
  5. Explore implications
```

## Framework Selection Guide

```
┌────────────────────────────────────────────────────────────────┐
│                 FRAMEWORK SELECTION MATRIX                      │
└────────────────────────────────────────────────────────────────┘

Goal                          Recommended Frameworks
─────────────────────────────────────────────────────────────────
Generate variations     →     SCAMPER, Lateral Thinking
Multi-perspective       →     Six Thinking Hats, Meta Thinking
User understanding      →     JTBD, Design Thinking, Example Mapping
Market fit             →     Value Proposition Canvas
System impact          →     Systems Thinking
Challenge assumptions  →     Lateral Thinking, Meta Thinking
Concretize ideas       →     Example Mapping, JTBD
Deep exploration       →     Socratic Dialogue, Design Thinking
```

## Execution Protocol

### Quick Mode (30 min)
1. Apply 2-3 most relevant frameworks
2. Generate key insights per framework
3. Synthesize top recommendations

### Standard Mode (60 min)
1. Apply 5-6 frameworks systematically
2. Cross-reference insights
3. Generate multiple proposals
4. Evaluate and rank

### Deep Mode (120+ min)
1. Apply all 10 frameworks comprehensively
2. Deep-dive into each perspective
3. Multiple iteration cycles
4. Comprehensive proposal generation
5. Detailed evaluation matrix

## Integration with /spc.evolve

```yaml
phase_mapping:
  CAPTURE:
    frameworks: [socratic_dialogue]
    purpose: "Extract and clarify initial idea"

  DECOMPOSE:
    frameworks: [example_mapping]
    purpose: "Break down into concrete scenarios"

  ANALYZE:
    frameworks: [jtbd, vpc, systems_thinking]
    purpose: "Deep structural analysis"

  DIVERGE:
    frameworks: [scamper, lateral_thinking, six_hats, design_thinking]
    purpose: "Generate diverse alternatives"

  SYNTHESIZE:
    frameworks: [meta_thinking]
    purpose: "Combine insights into proposals"

  EVALUATE:
    frameworks: [six_hats]  # Black + Yellow hats focus
    purpose: "Assess proposals critically"

  CRYSTALLIZE:
    frameworks: [example_mapping, vpc]
    purpose: "Finalize and document"
```

## Output Consolidation

After applying multiple frameworks, consolidate into:

```markdown
## Consolidated Insights

### Top 5 Insights (Cross-Framework)
1. [Insight] - Source: [Framework(s)]
2. [Insight] - Source: [Framework(s)]
...

### Emerging Patterns
- Pattern 1: [Description] (seen in F1, F3, F7)
- Pattern 2: [Description] (seen in F2, F5)

### Key Tensions
- Tension 1: [Framework A] suggests X, but [Framework B] suggests Y
- Resolution: [Recommendation]

### Recommended Direction
[Clear recommendation based on convergent insights]
```

## Guardrails

### MUST
- Apply at least 2 frameworks before making recommendations
- Document insights from each framework explicitly
- Cross-reference findings across frameworks
- Identify and resolve contradictions

### MUST NOT
- Apply frameworks superficially
- Skip frameworks that might challenge current thinking
- Ignore contradictory findings
- Rush through without proper reflection

### STOP CONDITIONS
- User unable to provide input for exploration
- Framework reveals fundamental flaw requiring restart
- Scope changes significantly mid-analysis