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

id, title, category, status, canonical_id, aliases, duplicate_of, source_trust_level, confidence_score, verification_status, tags, raw_sources, last_reinforced, github_commit, tech_stack

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

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

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)

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

def scqa(situation, complication, question, answer):
    return (
        f"**Situation**: {situation}\n"
        f"**Complication**: {complication}\n"
        f"**Question**: {question}\n"
        f"**Answer**: {answer}"
    )

2x2 framework

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

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 · Critical Thinking
• 변형: Pyramid Principle · Issue Tree
• 응용: Consulting · Technical Writing
• Adjacent: First Principles Thinking · 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 패턴