2nd/10_Wiki/Topics/Other/MECE + Pyramid Principle--.md

---
id: wiki-2026-0508-mece-pyramid-principle
title: MECE + Pyramid Principle
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [MECE, Pyramid Principle, 미씨 + 피라미드, McKinsey Framework]
duplicate_of: none
source_trust_level: A
confidence_score: 0.9
verification_status: applied
tags: [problem-solving, communication, structure, consulting, writing]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
  language: methodology
  framework: mckinsey
---

# MECE + Pyramid Principle

## 매 한 줄
> **"매 MECE 는 thinking, Pyramid 는 communication"**. MECE (Mutually Exclusive, Collectively Exhaustive) 는 문제 분해 원칙, Pyramid Principle 은 결론-우선 communication structure. Barbara Minto (1973) 의 McKinsey 표준. 2026 LLM 시대에도 prompt structuring / report writing 의 backbone.

## 매 핵심

### 매 MECE
- **Mutually Exclusive**: 각 카테고리 겹침 없음.
- **Collectively Exhaustive**: 모든 가능성 포함.
- 2x2 matrix, decision tree, issue tree 의 기본.

### 매 Pyramid Principle
- **Top**: governing thought / answer first.
- **Middle**: 3-5 supporting arguments (MECE).
- **Bottom**: data, evidence, examples.
- **SCQA opener**: Situation → Complication → Question → Answer.

### 매 응용
1. Consulting deliverable / executive summary.
2. Research paper structure.
3. LLM prompt design (system + sections).
4. Code review write-up.

## 💻 패턴

### Issue tree decomposition
```python
class Node:
    def __init__(self, q, children=None):
        self.q = q
        self.children = children or []

# Profit decline 분석
tree = Node("Why is profit declining?", [
    Node("Revenue down?", [
        Node("Volume down?"),
        Node("Price down?"),
    ]),
    Node("Cost up?", [
        Node("COGS up?"),
        Node("OpEx up?"),
    ]),
])
# 매 each level MECE
```

### MECE validator
```python
def is_mece(categories: list[set]) -> tuple[bool, bool]:
    universe = set.union(*categories)
    # ME: pairwise disjoint
    me = all(not (a & b) for i, a in enumerate(categories)
                          for b in categories[i+1:])
    # CE: union covers universe
    ce = set.union(*categories) == universe
    return me, ce
```

### Pyramid outliner (LLM)
```python
def pyramid_outline(question: str) -> dict:
    prompt = f"""Structure as Pyramid Principle:
1. Governing answer (1 sentence).
2. 3 MECE supporting arguments.
3. For each, 2-3 evidence bullets.

Question: {question}
Output JSON."""
    resp = client.messages.create(
        model="claude-opus-4-7",
        max_tokens=2048,
        messages=[{"role": "user", "content": prompt}],
    )
    return json.loads(resp.content[0].text)
```

### SCQA opener generator
```python
def scqa(situation, complication, question, answer):
    return (
        f"**Situation**: {situation}\n"
        f"**Complication**: {complication}\n"
        f"**Question**: {question}\n"
        f"**Answer**: {answer}"
    )
```

### 2x2 framework
```python
def matrix_2x2(items, axis_x, axis_y):
    quadrants = {"high-high": [], "high-low": [],
                 "low-high": [], "low-low": []}
    for item in items:
        x = "high" if axis_x(item) else "low"
        y = "high" if axis_y(item) else "low"
        quadrants[f"{x}-{y}"].append(item)
    return quadrants
```

### Top-down report builder
```python
def build_report(answer, args: list[dict]):
    out = [f"# {answer}\n"]
    for i, arg in enumerate(args, 1):
        out.append(f"## {i}. {arg['claim']}")
        for ev in arg["evidence"]:
            out.append(f"- {ev}")
    return "\n".join(out)
```

## 매 결정 기준
| 상황 | Approach |
|---|---|
| Problem decomposition | Issue tree (MECE at each level) |
| Executive deck | Pyramid + SCQA + 3 args |
| Categorization | 2x2 matrix or MECE list |
| LLM task | Pyramid in system prompt |

**기본값**: Issue tree 분석 → Pyramid 로 communicate.

## 🔗 Graph
- 부모: [[Problem Solving Process]]
- 변형: [[Pyramid Principle]] · [[Issue Tree]]
- 응용: [[Technical Writing]]
- Adjacent: [[Hypothesis-Driven]]

## 🤖 LLM 활용
**언제**: report drafting, prompt structuring, decomposition assistance.
**언제 X**: creative / divergent ideation — 매 over-constrains.

## ❌ 안티패턴
- **False MECE**: overlap 있는데 disjoint 라 가정.
- **Bottom-up dump**: data 먼저 늘어놓고 conclusion 마지막 → executive 가 lost.
- **Over-decomposition**: 7+ branches at one level → cognitive overload.
- **Forced 3 categories**: 매 항상 3 으로 강제 → exhaustiveness 깨짐.

## 🧪 검증 / 중복
- Verified (Minto 1973 "The Pyramid Principle", McKinsey training docs, HBR 2019).
- 신뢰도 A.

## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — issue tree + SCQA + 2x2 패턴 |