---
id: wiki-2026-0508-wicked-problems
title: Wicked Problems
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [Ill-Defined Problems, Complex Systems Problems]
duplicate_of: none
source_trust_level: A
confidence_score: 0.85
verification_status: applied
tags: [problem-solving, systems-thinking, design, methodology]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
  language: Methodology
  framework: Systems Thinking
---

# Wicked Problems

## 매 한 줄
> **"매 well-defined 의 X 한 problem"**. Rittel & Webber (1973) "Dilemmas in a General Theory of Planning" — 매 social policy / climate / AI safety / urban planning 의 characterize, 매 2026 AI alignment debate (Claude Opus 4.7 RLHF objective design) 의 textbook example.

## 매 핵심

### 매 10가지 특성 (Rittel-Webber)
1. No definitive formulation.
2. No stopping rule (when is it "solved"?).
3. Solutions are good/bad, not true/false.
4. No immediate or ultimate test of solution.
5. Every solution is a "one-shot operation" (no trial-and-error).
6. No enumerable set of potential solutions.
7. Every wicked problem is essentially unique.
8. Every wicked problem is a symptom of another problem.
9. Multiple explanations possible (choice depends on worldview).
10. Planner has no right to be wrong (consequences matter).

### 매 vs Tame problems
| Tame | Wicked |
|---|---|
| Clear goal | Goal contested |
| Defined boundary | Diffuse, expanding |
| Known solution methods | No clear method |
| Repeatable (chess, sudoku) | One-shot (urban policy) |
| Right/wrong | Better/worse |

### 매 응용 examples
1. Climate change.
2. Healthcare reform.
3. AI alignment / safety.
4. Homelessness.
5. Education policy.
6. Pandemic response.
7. LLM evaluation (what is "helpful"?).

## 💻 패턴

### Stakeholder mapping
```python
# Power-Interest grid
import matplotlib.pyplot as plt

stakeholders = {
    "Regulators": (9, 8),
    "Users": (3, 9),
    "Engineers": (5, 7),
    "Investors": (8, 5),
    "Public": (2, 6),
}
fig, ax = plt.subplots()
for name, (power, interest) in stakeholders.items():
    ax.scatter(power, interest)
    ax.annotate(name, (power, interest))
ax.set_xlabel("Power"); ax.set_ylabel("Interest")
ax.axhline(5); ax.axvline(5)
# Quadrants: Manage Closely / Keep Satisfied / Keep Informed / Monitor
```

### Causal Loop Diagram (CLD)
```
Symptom-fix vs root-fix:
   homelessness ↑ → shelter beds ↑ → visible homelessness ↓ (symptomatic)
                                    → root causes unaddressed → homelessness ↑ (R loop)

   homelessness ↑ → housing units ↑ → root addressed → homelessness ↓ (B loop, slow)
```

### Multi-criteria decision analysis (MCDA)
```python
import numpy as np

# Solutions × Criteria matrix
options = ["Tax", "Subsidy", "Regulate", "Invest"]
criteria = ["Equity", "Cost", "Speed", "Acceptance"]
weights = np.array([0.4, 0.2, 0.2, 0.2])
scores = np.array([
    [9, 4, 6, 3],   # Tax
    [7, 3, 8, 8],   # Subsidy
    [8, 7, 4, 5],   # Regulate
    [6, 2, 3, 7],   # Invest
])
ranking = scores @ weights
print(dict(zip(options, ranking)))
```

### Scenario planning
```python
# Build 2x2 scenario matrix on key uncertainties
def scenario_2x2(axis_x, axis_y, scenarios):
    """
    axis_x, axis_y: pairs (low, high) of critical uncertainties
    scenarios: 4 narrative descriptions
    """
    return {
        f"{axis_x[0]} + {axis_y[0]}": scenarios[0],
        f"{axis_x[1]} + {axis_y[0]}": scenarios[1],
        f"{axis_x[0]} + {axis_y[1]}": scenarios[2],
        f"{axis_x[1]} + {axis_y[1]}": scenarios[3],
    }
```

### Argument mapping
```python
# Decompose claim into premises + objections
class ArgumentNode:
    def __init__(self, claim, support=None, attack=None):
        self.claim = claim
        self.support = support or []  # premises
        self.attack = attack or []    # rebuttals

root = ArgumentNode(
    "Ban autonomous weapons",
    support=[
        ArgumentNode("They lack moral judgment"),
        ArgumentNode("Risk of escalation"),
    ],
    attack=[
        ArgumentNode("Defensive use can save lives"),
    ]
)
```

### Adaptive management (Holling)
```python
# Iterate: model → act → monitor → revise
def adaptive_loop(problem, max_iter=10):
    model = initial_model(problem)
    for i in range(max_iter):
        action = decide(model)
        result = act_and_observe(action)
        model = update(model, result)
        if converged(model): break
    return model
# Embraces uncertainty — wicked problems lack closed-form solutions
```

## 매 결정 기준
| 상황 | Approach |
|---|---|
| Single optimal solution exists | Tame — use OR/optimization |
| Multiple stakeholders, contested goals | Wicked — stakeholder + scenario |
| Long-time-horizon, uncertain | Adaptive management |
| Ethics-laden | Argument mapping + deliberation |
| LLM RLHF reward design | Treat as wicked — pluralistic eval |

**기본값**: Acknowledge wickedness, use stakeholder mapping + MCDA + adaptive iteration; avoid pretending it's tame.

## 🔗 Graph
- 부모: [[Problem_Solving|Problem-Solving]] · [[Systems_Thinking|Systems-Thinking]]
- 응용: [[AI_Safety_and_Alignment|AI-Alignment]]
- Adjacent: [[Root-Cause-Analysis-RCA]] · [[Complex-Adaptive-Systems]]

## 🤖 LLM 활용
**언제**: Policy design, AI safety / alignment problems, multi-stakeholder system design (no objective ground truth), strategy under deep uncertainty.
**언제 X**: Engineering bug — use RCA. Optimization with clear objective — use OR. Well-specified algorithm — use complexity theory.

## ❌ 안티패턴
- **Treat wicked as tame**: 매 wicked problem 의 single-objective optimization 의 reduce → 매 unintended consequences (e.g., Goodhart's law).
- **Analysis paralysis**: 매 wicked problem 의 wait for "complete" understanding — 매 never come.
- **Ignore stakeholders**: 매 technocratic top-down 의 wicked problem 의 fail (Robert Moses urban renewal).
- **One-shot deployment**: 매 ship-and-forget — wicked problems 의 adaptive iteration 의 require.

## 🧪 검증 / 중복
- Verified (Rittel & Webber 1973 seminal paper, Conklin "Dialogue Mapping" 2005, Snowden "Cynefin").
- 신뢰도 A.

## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — Wicked problems with 10 traits, MCDA, scenario, AI alignment angle |