Transformation Workflow

Transformation Workflow Skill

Practical guide for applying HUMMBL's 6 transformations to real-world problems. Provides step-by-step workflows, combination patterns, templates, and examples for effective mental model usage.

Overview

The 6 HUMMBL transformations represent different cognitive operations:

1. Perspective (P): Frame and name what is
2. Inversion (IN): Reverse assumptions
3. Composition (CO): Combine parts into wholes
4. Decomposition (DE): Break wholes into components
5. Recursion (RE): Iterate, feedback, self-reference
6. Meta-Systems (SY): Coordinate systems-of-systems

When to Use Each Transformation

Perspective (P) - Use When:

Problem Indicators:

• ✅ Problem statement unclear or ambiguous
• ✅ Stakeholders have conflicting views
• ✅ Need to understand different viewpoints
• ✅ Framing feels wrong or limiting
• ✅ Context not fully understood

Trigger Questions:

• "How do different people see this?"
• "What am I missing in how I frame this?"
• "Whose perspective matters here?"
• "What context am I ignoring?"

Best For:

• Requirements gathering
• Stakeholder analysis
• Problem definition
• User research
• Strategic framing

Inversion (IN) - Use When:

Problem Indicators:

• ✅ Stuck with conventional thinking
• ✅ Need fresh perspective
• ✅ Want to avoid failure
• ✅ Looking for non-obvious solutions
• ✅ Need to challenge assumptions

Trigger Questions:

• "What's the opposite approach?"
• "What if this fails - why?"
• "What should we NOT do?"
• "What assumptions can we reverse?"

Best For:

• Brainstorming
• Risk analysis
• Innovation
• Assumption testing
• Creativity boost

Composition (CO) - Use When:

Problem Indicators:

• ✅ Have multiple components to integrate
• ✅ Need to build cohesive solution
• ✅ Want synergies between parts
• ✅ Creating system from pieces
• ✅ Assembling team/resources

Trigger Questions:

• "How do these parts work together?"
• "What synergies exist?"
• "How to integrate this?"
• "What's the whole picture?"

Best For:

• Solution design
• System architecture
• Team formation
• Strategy synthesis
• Product development

Decomposition (DE) - Use When:

Problem Indicators:

• ✅ System too complex to understand
• ✅ Need to find root cause
• ✅ Looking for bottlenecks
• ✅ Want to prioritize efforts
• ✅ Debugging or troubleshooting

Trigger Questions:

• "What are the parts?"
• "Why is this happening?"
• "Where's the constraint?"
• "What's essential vs nice-to-have?"

Best For:

• Problem diagnosis
• System analysis
• Prioritization
• Root cause analysis
• Debugging

Recursion (RE) - Use When:

Problem Indicators:

• ✅ Dealing with feedback loops
• ✅ Iterative process needed
• ✅ Self-reinforcing dynamics present
• ✅ Need progressive improvement
• ✅ Growth/decline accelerating

Trigger Questions:

• "What's feeding back into itself?"
• "How do we iterate?"
• "What cycles exist here?"
• "What's the second-order effect?"

Best For:

• Growth strategy
• Process improvement
• System dynamics
• Iterative development
• Feedback management

Meta-Systems (SY) - Use When:

Problem Indicators:

• ✅ Strategic decision needed
• ✅ Multiple systems interacting
• ✅ Long-term consequences matter
• ✅ Systemic intervention needed
• ✅ Choosing which model to use

Trigger Questions:

• "What's the systems view?"
• "What are second/third-order effects?"
• "Where's the leverage point?"
• "Which mental model applies?"

Best For:

• Strategic planning
• System design
• Leverage point identification
• Model selection
• Long-term thinking

Transformation Workflows

Workflow 1: Perspective Analysis

Input: Problem statement, context

Steps:

1. State the problem (1 sentence)
2. List stakeholders (P2: Stakeholder Mapping)
   • Who is affected?
   • Who has power?
   • Who has information?
3. Apply multiple lenses (P4: Lens Shifting)
   • Technical lens
   • Business lens
   • User lens
   • Ethical lens
4. Identify first principles (P1)
   • What must be true?
   • What are non-negotiables?
   • What are fundamental constraints?
5. Document context (P8: Context Awareness)
   • Time constraints
   • Resource constraints
   • Political/cultural factors

Output Format:

## Perspective Analysis

**Problem:** [1-sentence problem statement]

**Stakeholders:**
- [Stakeholder 1]: [Their perspective/interest]
- [Stakeholder 2]: [Their perspective/interest]
- [Stakeholder 3]: [Their perspective/interest]

**Multiple Lenses:**
- **Technical:** [Technical view]
- **Business:** [Business view]
- **User:** [User view]
- **Ethical:** [Ethical considerations]

**First Principles:**
1. [Fundamental truth 1]
2. [Fundamental truth 2]
3. [Fundamental truth 3]

**Context:**
- **Time:** [Timeline factors]
- **Resources:** [Resource constraints]
- **Environment:** [External factors]

**Insights:**
- [Key insight 1]
- [Key insight 2]

Example: Software architecture decision

• Problem: Choose between microservices vs monolith
• Stakeholders: Engineering (prefers interesting tech), Product (wants speed), Operations (wants stability)
• Lenses: Technical (complexity trade-offs), Business (cost/time), User (performance)
• First Principles: Team size matters more than technology
• Output: Decision framework based on team constraints, not tech fashion

Workflow 2: Inversion Analysis

Input: Problem, current approach

Steps:

1. State current approach
2. Apply inversion (IN1)
   • What if we did the opposite?
   • What would the inverse solution look like?
3. Run premortem (IN8)
   • Assume total failure in 6 months
   • Why did it fail?
   • What went wrong?
4. Apply via negativa (IN3)
   • What should we STOP doing?
   • What to remove, not add?
5. Seek disconfirmation (IN15)
   • What evidence contradicts our plan?
   • Who disagrees and why?

Output Format:

## Inversion Analysis

**Current Approach:** [Description]

**Inverted Approach:**
- Instead of [X], what if we [opposite of X]?
- Result: [Insights from inversion]

**Premortem (Assume Failure):**
- **Failure Scenario:** [What failed]
- **Root Cause:** [Why it failed]
- **Warning Signs:** [Early indicators we missed]

**Via Negativa (What to STOP):**
- Stop: [Thing 1]
- Stop: [Thing 2]
- Stop: [Thing 3]

**Disconfirming Evidence:**
- [Evidence against our approach]
- [Counterargument]
- [Risk we're underestimating]

**Revised Approach:**
- [Improvements based on inversion]

Example: Product launch strategy

• Current: Big launch event, lots of marketing
• Inversion: What if we did quiet launch to small group?
• Premortem: Event flops because nobody cares, spent budget wrong
• Via Negativa: Stop assuming launch is most important thing
• Output: Phased launch, test with early adopters first

Workflow 3: Composition Strategy

Input: Components, requirements

Steps:

1. List all components
2. Identify synergies (CO1)
   • Where do parts enhance each other?
   • What emergent properties arise?
3. Design synthesis (CO4)
   • How to merge into coherent whole?
   • What's the unifying concept?
4. Plan orchestration (CO19)
   • How to coordinate components?
   • What's the execution sequence?
5. Create holistic integration (CO20)
   • Complete unified system
   • No loose ends

Output Format:

## Composition Strategy

**Components:**
1. [Component 1] - [Purpose]
2. [Component 2] - [Purpose]
3. [Component 3] - [Purpose]

**Synergies:**
- [Comp A] + [Comp B] = [Synergy]
- [Comp B] + [Comp C] = [Synergy]

**Synthesis Design:**
- **Unifying Concept:** [Central idea that ties everything]
- **Integration Points:** [Where components connect]
- **Emergent Properties:** [New capabilities from combination]

**Orchestration Plan:**
1. [Phase 1]: [Components + actions]
2. [Phase 2]: [Components + actions]
3. [Phase 3]: [Components + actions]

**Holistic Integration:**
- [How all pieces form complete system]
- [Quality properties of whole]

Example: Building product ecosystem

• Components: Core product, API, marketplace, analytics
• Synergies: API enables marketplace, marketplace drives analytics, analytics improves product
• Synthesis: Platform strategy
• Output: Integrated ecosystem with network effects

Workflow 4: Decomposition Analysis

Input: Complex system or problem

Steps:

1. Define the whole
2. Find root cause (DE1)
   • 5 Whys technique
   • Causal chain analysis
3. Apply divide & conquer (DE2)
   • Break into logical subsystems
   • Identify interfaces
4. Identify bottleneck (DE6)
   • Theory of Constraints
   • What's the limiting factor?
5. Pareto analysis (DE7)
   • What's the vital 20%?
   • Where to focus effort?

Output Format:

## Decomposition Analysis

**System:** [Description of whole]

**Root Cause Analysis:**
- Why? [Reason 1]
  - Why? [Reason 2]
    - Why? [Reason 3]
      - Why? [Reason 4]
        - Why? [ROOT CAUSE]

**Component Breakdown:**
├── [Component A]
│   ├── [Subcomponent A1]
│   └── [Subcomponent A2]
├── [Component B]
│   ├── [Subcomponent B1]
│   └── [Subcomponent B2]
└── [Component C]

**Bottleneck:**
- **Constraint:** [Limiting factor]
- **Impact:** [How it limits system]
- **Intervention:** [How to address]

**Pareto (80/20):**
- **Vital Few (20%):**
  - [Critical element 1]
  - [Critical element 2]
- **Trivial Many (80%):**
  - [Less critical elements]

**Action Plan:**
1. [Address root cause]
2. [Remove bottleneck]
3. [Focus on vital 20%]

Example: Website performance issues

• Root Cause: Inefficient database queries (not server capacity)
• Breakdown: Frontend, API, Database, Cache, CDN
• Bottleneck: Database query on user table
• Pareto: 3 queries cause 80% of slow responses
• Output: Optimize those 3 queries first

Workflow 5: Recursion Analysis

Input: System with dynamics over time

Steps:

1. Map feedback loops (RE1)
   • Positive (reinforcing)
   • Negative (balancing)
2. Identify virtuous cycles (RE7)
   • What creates growth?
   • How to amplify?
3. Identify vicious cycles (RE8)
   • What creates decline?
   • How to break?
4. Design iteration (RE2)
   • How to improve progressively?
   • What's the learning loop?
5. Analyze second-order (RE19)
   • Effects of effects
   • Compound dynamics

Output Format:

## Recursion Analysis

**System Dynamics:**

**Feedback Loops:**
- ➕ **Virtuous Cycle:** [A] → [B] → [C] → [More A]
- ➖ **Vicious Cycle:** [X] → [Y] → [Z] → [More X]
- ⚖️ **Balancing Loop:** [M] → [N] → [Less M]

**Virtuous Cycles (Amplify These):**
1. [Positive cycle 1]
   - Trigger: [What starts it]
   - Amplify: [How to strengthen]
2. [Positive cycle 2]

**Vicious Cycles (Break These):**
1. [Negative cycle 1]
   - Cause: [What perpetuates it]
   - Intervention: [How to break]
2. [Negative cycle 2]

**Iterative Improvement:**
- **Version 1:** [Initial state]
- **Learn:** [What to measure]
- **Improve:** [What to adjust]
- **Repeat:** [Cycle time]

**Second-Order Effects:**
- First-order: [Direct effect]
- Second-order: [Effect of effect]
- Third-order: [Effect of effect of effect]

**Leverage Points:**
- [Where small change creates big impact]

Example: SaaS growth

• Virtuous Cycle: Good product → Happy users → Referrals → More users → More feedback → Better product
• Vicious Cycle: Bugs → Bad reviews → Fewer signups → Less revenue → Less engineering → More bugs
• Iteration: Weekly releases, measure NPS, improve top complaint
• Output: Strategy to amplify virtuous, break vicious cycles

Workflow 6: Meta-Systems Strategy

Input: Strategic question or complex system

Steps:

1. Apply systems thinking (SY1)
   • See whole system
   • Identify interconnections
2. Second-order thinking (SY2)
   • Consequences of consequences
   • Nth-order effects
3. Find leverage points (SY4)
   • Where to intervene?
   • High-impact, low-effort
4. Anticipate unintended consequences (SY5)
   • What could go wrong?
   • Side effects?
5. Model selection (SY19)
   • Which other models apply?
   • What's the right analytical approach?

Output Format:

## Meta-Systems Strategy

**Strategic Question:** [Question]

**Systems View:**
┌─────────────────────────────────┐
│  [System Component 1]           │
│    ↓ ↑                          │
│  [System Component 2]           │
│    ↓ ↑                          │
│  [System Component 3]           │
└─────────────────────────────────┘

**Interconnections:**
- [A] affects [B] via [mechanism]
- [B] affects [C] via [mechanism]
- [C] feeds back to [A] via [mechanism]

**Second-Order Analysis:**
| Action | 1st Order | 2nd Order | 3rd Order |
|--------|-----------|-----------|-----------|
| [Action 1] | [Direct effect] | [Effect of effect] | [Further effect] |
| [Action 2] | [Direct effect] | [Effect of effect] | [Further effect] |

**Leverage Points** (Highest to Lowest Impact):
1. **[Point 1]:** [Why high leverage]
2. **[Point 2]:** [Why medium leverage]
3. **[Point 3]:** [Why low leverage]

**Unintended Consequences:**
- Risk: [Potential negative outcome]
- Mitigation: [How to prevent]

**Model Selection:**
- Primary: [Model code + name]
- Secondary: [Model code + name]
- Why: [Justification]

**Recommended Strategy:**
- [Strategic approach based on analysis]

Example: Market expansion decision

• Systems View: Current market, new market, competitors, resources
• Second-Order: Enter new market → Spread resources thin → Lose focus in current market → Competitors gain ground
• Leverage: Instead of new market, deepen penetration in current (10x ROI)
• Output: Stay focused strategy, not expansion

Combination Patterns

Pattern 1: P → DE → CO (Understand → Analyze → Build)

Use Case: Building new solution
Steps:

1. Perspective: Understand problem from multiple angles
2. Decomposition: Break down into components
3. Composition: Integrate into solution

Example: Designing new feature

• P: Stakeholder needs (users want X, business wants Y)
• DE: Break into sub-features, identify dependencies
• CO: Integrate into cohesive feature with good UX

Pattern 2: P → IN → SY (Frame → Challenge → Strategy)

Use Case: Strategic decision
Steps:

1. Perspective: Frame the situation
2. Inversion: Challenge assumptions
3. Meta-Systems: Strategic synthesis

Example: Business model pivot

• P: Current model's perspective, customer viewpoint
• IN: What if opposite? What to stop?
• SY: Strategic choice based on systems thinking

Pattern 3: DE → IN → CO (Analyze → Invert → Rebuild)

Use Case: Innovation/redesign
Steps:

1. Decomposition: Understand current system
2. Inversion: Challenge how it works
3. Composition: Build new solution

Example: Process improvement

• DE: Map current process, find bottleneck
• IN: What if we removed steps? Did opposite?
• CO: Redesigned process

Pattern 4: All 6 in Sequence (Complete Analysis)

Use Case: Major strategic initiative
Steps:

1. P: Frame problem
2. IN: Challenge assumptions
3. DE: Analyze components
4. CO: Build solution
5. RE: Plan iteration
6. SY: Strategic integration

Example: Company transformation

• Use all 6 transformations systematically
• Comprehensive, robust analysis
• Takes longer but minimizes blind spots

Pattern 5: RE wrapping any other (Iterative Application)

Use Case: Continuous improvement
Structure: RE(P/IN/CO/DE/SY)

Example: Product development

• Week 1: P (understand users)
• Week 2: DE (analyze feedback)
• Week 3: CO (build improvements)
• Week 4: RE (iterate based on results)
• Repeat

Common Pitfalls & Solutions

Pitfall 1: Using Wrong Transformation

Error: Applying Decomposition when need Perspective
Symptom: Breaking down problem doesn't help because problem not understood
Solution: Start with P (frame first), then DE (analyze)

Pitfall 2: Skipping Inversion

Error: Going straight to solution without challenging assumptions
Symptom: Conventional thinking, missing creative options
Solution: Always apply IN before finalizing approach

Pitfall 3: Decomposition Without Recomposition

Error: Breaking things down but never synthesizing
Symptom: Analysis paralysis, no actionable solution
Solution: DE must be followed by CO (analyze then build)

Pitfall 4: Ignoring Feedback Loops

Error: Linear thinking in dynamic system
Symptom: Interventions don't work as expected
Solution: Apply RE to understand dynamics

Pitfall 5: Local Optimization

Error: Optimizing parts without seeing whole
Symptom: Suboptimization, missing systemic issues
Solution: Use SY (systems view) before optimizing

Pitfall 6: Single-Model Thinking

Error: Using only one model/transformation
Symptom: One-dimensional analysis, blind spots
Solution: Combine multiple transformations (patterns above)

Pitfall 7: Overcomplication

Error: Applying all 6 when 2 would suffice
Symptom: Slow progress, diminishing returns
Solution: Start simple (1-2 transformations), add if needed

Transformation Selection Flowchart

START: What's your primary need?

├─ "Understand the problem"
│  → Use PERSPECTIVE (P)
│  → Then consider: DE (analyze) or IN (challenge)

├─ "Stuck or need creativity"
│  → Use INVERSION (IN)
│  → Then consider: P (reframe) or CO (rebuild)

├─ "Build/integrate solution"
│  → Use COMPOSITION (CO)
│  → Likely needed: DE first (analyze parts)

├─ "Analyze complex system"
│  → Use DECOMPOSITION (DE)
│  → Then consider: CO (reintegrate) or SY (systems view)

├─ "Handle dynamics/feedback"
│  → Use RECURSION (RE)
│  → Then consider: SY (systemic) or DE (analyze loops)

└─ "Strategic/systemic decision"
   → Use META-SYSTEMS (SY)
   → Then consider: P (perspectives) + IN (challenge)

Quick Templates

5-Minute Quick Analysis

1. P: Who are stakeholders? (30 sec)
2. IN: What's the opposite? (30 sec)
3. DE: What's the bottleneck? (1 min)
4. CO: How to integrate? (1 min)
5. RE: What's the feedback? (1 min)
6. SY: What's the leverage? (1 min)

One-Page Strategy

Problem: [1 sentence]
Perspective: [Key stakeholders, key lens]
Inversion: [What NOT to do]
Decomposition: [Critical components]
Composition: [How they integrate]
Recursion: [Key feedback loop]
Systems: [Leverage point]
Action: [Next step]

Resources

• HUMMBL Framework Skill: Complete model reference
• Model Codes: P1-P20, IN1-IN20, CO1-CO20, DE1-DE20, RE1-RE20, SY1-SY20
• Quality Standard: 9.0/10 minimum for application
• Validation: Oct 29, 2025 Base120 specification

Success Criteria

Effective transformation application achieves:

• ✅ Clear process followed
• ✅ Appropriate transformation selected
• ✅ Insights generated (not just analysis)
• ✅ Actionable outputs
• ✅ Documented reasoning

Application fails if:

• ❌ Wrong transformation chosen
• ❌ Process skipped/rushed
• ❌ No insights emerged
• ❌ Can't act on results
• ❌ Reasoning not documented