transformation-workflow

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

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

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?

1. Apply multiple lenses (P4: Lens Shifting)

- Technical lens

- Business lens

- User lens

- Ethical lens

1. Identify first principles (P1)

- What must be true?

- What are non-negotiables?

- What are fundamental constraints?

1. Document context (P8: Context Awareness)

- Time constraints

- Resource constraints

- Political/cultural factors

Output Format:

```markdown

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?

1. Run premortem (IN8)

- Assume total failure in 6 months

- Why did it fail?

- What went wrong?

1. Apply via negativa (IN3)

- What should we STOP doing?

- What to remove, not add?

1. Seek disconfirmation (IN15)

- What evidence contradicts our plan?

- Who disagrees and why?

Output Format:

```markdown

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?

1. Design synthesis (CO4)

- How to merge into coherent whole?

- What's the unifying concept?

1. Plan orchestration (CO19)

- How to coordinate components?

- What's the execution sequence?

1. Create holistic integration (CO20)

- Complete unified system

- No loose ends

Output Format:

```markdown

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

1. Apply divide & conquer (DE2)

- Break into logical subsystems

- Identify interfaces

1. Identify bottleneck (DE6)

- Theory of Constraints

- What's the limiting factor?

1. Pareto analysis (DE7)

- What's the vital 20%?

- Where to focus effort?

Output Format:

```markdown

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)

1. Identify virtuous cycles (RE7)

- What creates growth?

- How to amplify?

1. Identify vicious cycles (RE8)

- What creates decline?

- How to break?

1. Design iteration (RE2)

- How to improve progressively?

- What's the learning loop?

1. Analyze second-order (RE19)

- Effects of effects

- Compound dynamics

Output Format:

```markdown

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]

1. [Positive cycle 2]

Vicious Cycles (Break These):

1. [Negative cycle 1]

- Cause: [What perpetuates it]

- Intervention: [How to break]

1. [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

1. Second-order thinking (SY2)

- Consequences of consequences

- Nth-order effects

1. Find leverage points (SY4)

- Where to intervene?

- High-impact, low-effort

1. Anticipate unintended consequences (SY5)

- What could go wrong?

- Side effects?

1. Model selection (SY19)

- Which other models apply?

- What's the right analytical approach?

Output Format:

```markdown

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

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

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

```

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)

```

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]

• 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

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