Control Machine Mapping

---
name: control-machine-mapping
description: A skill for tracing systems of control through need, addiction, and dependence - understanding how power operates through the creation and management of desires.
license: MIT
metadata:
  author: sethmblack
  version: 1.0.3684
repository: https://github.com/sethmblack/paks-skills
keywords:
- control-machine-mapping
- escalation
- structure
- writing
---

# Control Machine Mapping

A skill for tracing systems of control through need, addiction, and dependence - understanding how power operates through the creation and management of desires.

## When to Use

- When analyzing how systems create the needs they satisfy
- When examining addiction, dependency, and compulsion as political mechanisms
- When trying to understand how control operates without overt force
- When mapping the "pusher" relationship in any domain

## Inputs

| Input | Required | Description |
|-------|----------|-------------|
| input_data | Yes | The primary data or content to analyze |
| context | No | Additional background or constraints (default: none) |
| output_format | No | Preferred format for results (default: structured markdown) |

## Workflow
### Step 1: Phase 1: Identify the Created Need

Find what desire is manufactured:
- What do people in this system "need" that they wouldn't without it?
- How is the need created? (Marketing, architecture, habit formation, social pressure)
- What did people do before this need existed?
- What makes the need feel natural rather than constructed?

Control begins with making you want what they're selling.

### Step 2: Phase 2: Analyze the Supply Mechanism

Understand how the need is satisfied:
- Who controls the supply?
- How is access granted or denied?
- What must you do to get your fix?
- What happens when supply is interrupted?

The pusher and the junkie is the fundamental relationship of control.

### Step 3: Phase 3: Map the Feedback Loop

Trace how satisfaction reinforces need:
- Does satisfaction reduce or increase desire?
- How does the system create escalation?
- What withdrawal symptoms exist?
- How does the cycle self-perpetuate?

The best control machines are self-reinforcing.

### Step 4: Phase 4: Identify the Compliance Mechanism

Find how need produces obedience:
- What behavior is required to access supply?
- What behavior must be avoided?
- How does anticipated need shape present action?
- What would you do (or not do) to maintain supply?

Need creates compliance without commands.

### Step 5: Phase 5: Locate the Control Operators

Identify who benefits:
- Who profits from the need and its satisfaction?
- Who gains power from controlling supply?
- Who designed this system (if anyone)?
- What maintains it even without individual designers?

Control machines can be designed or emergent.

### Step 6: Phase 6: Find the Exit

Identify routes out:
- How can the need be reduced or eliminated?
- What alternative satisfactions exist?
- How can the feedback loop be broken?
- What does withdrawal look like?

Every control machine has weaknesses. Find them.

## Output Format

A control machine map including:
1. The domain and its created need
2. Need creation mechanisms
3. Supply control analysis
4. Feedback loop diagram
5. Compliance mechanisms
6. Control operators identified
7. Exit routes and their costs

## Constraints

- Not every need is manufactured or controlling
- Genuine needs exist and shouldn't be dismissed as control
- The analysis can become paranoid
- Finding the exit is often easier than taking it
- You are probably inside control machines as you analyze them

## Outputs

**Primary Output:** A structured analysis document that identifies and articulates patterns, insights, and actionable recommendations based on the input data.

**Format:**
```markdown
## Analysis: [Topic]

### Key Findings
- [Finding 1]
- [Finding 2]
- [Finding 3]

### Recommendations
1. [Action 1]
2. [Action 2]
3. [Action 3]
```

**Example output:** See the Example section below for a complete demonstration.

## Additional Notes

**Best practices:**
- Use this skill when the situation clearly matches its intended use cases
- Combine with related skills for comprehensive analysis
- Iterate on outputs if initial results don't fully meet requirements

**Common variations:**
- Adjust the depth of analysis based on available time and information
- Scale the approach for different levels of complexity
- Adapt the output format to audience needs

**When to skip this skill:**
- The situation doesn't match the core use cases
- Simpler approaches would be more appropriate
- Time constraints require faster methods

## Example

**Input**: Map social media as control machine

**Output**:
"Domain: Social media platforms. Created need: Social validation (likes, comments, followers), information currency (knowing what's happening), entertainment/stimulation. Need creation: Intermittent variable rewards (like slot machines); social pressure (everyone is there); fear of missing out; notification systems that interrupt and demand attention. Supply mechanism: Platform controls algorithmic distribution; visibility determined by rules users don't know; supply of validation can be increased or decreased arbitrarily. Feedback loop: Validation creates desire for more validation; content creation to earn validation becomes habit; escalation required as tolerance builds. Compliance: Must produce content, engage with others' content, tolerate advertising, provide data, follow platform rules or lose access to social graph. Control operators: Platform shareholders (profit from engagement); advertisers (buy access to attention); platform itself (extracts data and behavior). Exit routes: Alternative platforms (but social graph doesn't move); cold turkey (but social costs); intentional limited use (requires constant discipline). Exit cost: Real social connection loss, not just platform."

## Integration

Works with:
- **word-virus-analysis**: Language is one control mechanism
- **routine-disruption**: Breaking habits exits control machines
- **structural-critique**: Control machines are part of larger systems