Pyramid principle full

The Minto Pyramid Principle — Full-Fidelity Staged Workflow

Distilled exhaustively from The Minto Pyramid Principle: Logic in Writing, Thinking and Problem Solving (Barbara Minto, 2010 ed., 254 pp.) — the complete text and all 149 exhibits, not a summary of headings. Session files carry chapter/page citations back to the source corpus (pyramid-principles-pdf.pdf/ when working in this repo). Known source lacuna: book pp. 34–35 (Ch 4 opening + Exhibit 9) are missing from the scan; their argument is bridged from the surviving continuation, never invented.

Execution contract (read BEFORE Session 0 — governs how this skill is deployed)

This methodology is a compression: a large input body becomes a small pyramid, and every session after 3 operates on the pyramid, not the input. Deployments that miss this re-ground each stage in the input and cost 5–10×. Five rules, in priority order.

1. Bound the input body at Session 0 — and state its token cost. Session 0 must name the input body and estimate it (wc -w × 1.4 ≈ tokens), recorded in the worklog.

Declared input	Action
≤ 30K tokens	proceed (Tier A — inline, no subagents at all)
30–150K tokens	proceed (Tier B — inline spine + the rule-3 boundaries)
> 150K tokens	STOP. Scope down to the governing documents, or justify the full read in the worklog

Modes C and R need only the documents that govern the message — never the whole corpus that produced it. (Observed failure, 2026-07-10: a mode-C run declared a 126-file / ~740K-token corpus where the two governing documents — ~91K tokens — carried the entire message. 8× oversize, and it set the floor for the whole run's cost.)

2. Run the spine INLINE — never one agent per session. Sessions 0–4 and 9 stay in one context. One-agent-per-session is the worst decomposition available here: the hard-stop protocol serialises the agents anyway, so it buys zero parallelism while paying full fan-out cost — every agent cold-starts and re-receives the pyramid, the worklog (which grows all run), and the input. Inline, the pyramid stays cache-warm and each session costs only its own thinking.

3. Fan out at exactly two boundaries — nowhere else.

Boundary	When	Shape	Cap
S3 corpus extraction	the bounded input still exceeds one comfortable context	one agent per corpus slice; each returns ≤2K tokens of candidate ideas + citations — never prose, never a summary of its slice	~12
S10 critique panel	stakes justify genuinely independent lenses	one agent per lens over the frozen artifact	4

Never fan out Sessions 4–8 — for two reasons, the second of which is the binding one. Cost: they audit a pyramid already in the lead's context, so a fan pays to re-transmit it and returns nothing the lead could not derive more cheaply. Correctness: their central judgments are cross-grouping and cannot be made from inside one grouping — Session 6's completeness interrogation ("what step, part or member is missing?"), Session 7's universal question ("why have I brought together these particular ideas and no others?"), and the misfit scan all require seeing the siblings at once. A per-grouping agent cannot notice that its misfit belongs in the grouping next door. Even where the pyramid is large enough that per-grouping parallelism looks tempting, this is the wrong cut.

Both fans are implemented ready-to-run in ~/.claude/workflows/pyramid-fans.mjs (versioned beside this skill at workflows/pyramid-fans.mjs): call it with args.phase="extract" + args.slices, or args.phase="critique" + args.artifact. Everything between those two calls — pyramid assembly, Sessions 4–8, drafting — stays in the lead. Note what the fans return: slice-readers return grounded candidates, never structure, because grouping and ordering need every candidate at once and that judgment is the lead's; critique lenses return defects with an owning session, never rewrites.

4. Cap the rework loop at 2 rounds. Session 10's "iterate until clean" is bounded. A third round means the defect is structural — return to the owning session (3/5/6/7), fix it once there, re-run only the gates the fix touches, and log what remains in the variance log instead of looping.

5. Suspend the "orchestrate + adversarially verify" posture. A standing directive to author a workflow for every task, spawn refuter panels, and loop until dry is wrong for this skill. The per-session exit checklists and Session 8's gates are the verification; adding refuter panels on top verifies the verifier, and is the largest single source of runaway cost. Reach for a Dynamic Workflow only for the two boundaries in rule 3.

Budget. A correctly-bounded run costs ~1× the input body plus ~60–120K tokens of thinking, and lands in 10–15 minutes. Trending past 2× the input body means rule 1 or rule 2 is being violated — stop and re-read this section.

Audit. Rules 1 and 4 are mechanically checkable after the fact — run scripts/pyramid-worklog-lint.sh <worklog> (fail-closed: exit 1 on violation). It asserts Session 0 recorded a bounded input with a token estimate and a tier, that the rework loop stayed within 2 rounds, and warns when the Session 3 pyramid carries no citations — the condition that forces later sessions back into the source corpus.

Operating doctrine (always in force, every session)

1. Think first, write later. No final prose, slides, or formatting may be drafted before the Pre-Writing Gate (Session 8) passes. The clarity of the end product comes from the pyramidal ordering of ideas, not the refinement of style (Ch 3, p. 30). Depth limit: structure the pyramid only to one level below the Key Line before drafting — Minto recommends you then "just sit down and write," developing lower-level ideas as you reach them (Part 2 intro, p. 73); those drafted-in levels are audited afterward in Session 10.
2. You cannot know what you think until you symbolize it — say it out loud or write it down (Ch 2, p. 12). Every session therefore produces a written artifact in the worklog. Thinking that is not written down has not happened.
3. The mind's limits govern. Nobody holds more than ~7 items (aim ≤4–5 per grouping, Ch 6 p. 78); readers take sentences one at a time and impose structure on whatever arrives; therefore always give the summarizing idea before the ideas summarized (Ch 1, p. 5).
4. The three pyramid rules (Ch 1, p. 9) are the constitution:
   • Ideas at any level must be summaries of the ideas grouped below them.
   • Ideas in each grouping must be the same kind of idea (one plural noun).
   • Ideas in each grouping must be in logical order (one of only four: deductive-argument order, time, structural, degree — because reasoning deductively, tracing cause/effect, dividing a whole, and categorizing are the only analytical activities the mind performs).
5. The three substructures (Ch 2): vertical question/answer dialogue; horizontal deductive-or-inductive (never both at once) logic; the narrative S-C-Q introductory flow. Never raise a question you aren't ready to answer; never answer a question you haven't raised.
6. Rule-break = thinking flaw. When any check fails, the defect is in the ideas, not the wording — return to the responsible session and rework (Ch 1, p. 11).

Hard-stop protocol

• Sessions run strictly in sequence for the chosen mode. A session may begin only when the previous session's exit checklist is fully checked and its artifact is appended to the worklog.
• Hard stop means: finish the session's deliverable, run its exit checks, write the artifact — then and only then move on. No look-ahead drafting, no skipping, no "we'll fix it later".
• Worklog: create <output-name>.pyramid-worklog.md beside the intended deliverable at Session 0. Each session appends: ## Session N — <title> / decisions taken / the artifact / exit-checklist state / open risks. The worklog is the audit trail of the "mind of the Pyramid Principle" working over the input.
• Rework loops: a failed check in Sessions 5–8 or 10 names the session that owns the defect; go back, fix, re-run every downstream gate that the fix touches. Bounded to 2 rounds (Execution contract, rule 4) — a third means the defect is structural: fix it once in the owning session and log the residual in the variance log rather than looping.
• Interactive mode: if the user says "interactive" (or the stakes warrant it), pause at each hard stop and present the artifact for approval before continuing. Default: continue autonomously but strictly sequentially.

Session 0 — Intake, classification, routing (do now, in-line)

1. Identify and bound the input body — name the files, measure them, record the token estimate in the worklog, and scope to the governing documents unless a wider read is justified in writing (Execution contract, rule 1) — then the reader(s) (one person? committee? wide circulation?), the medium (memo/report/proposal/dot-dash "lap visual"/presentation/prose/email), the desired length, and any user constraints. If the medium is not user-fixed, choose it by Minto's rule (Part 4 intro, p. 168): short message + one/few readers → prose memo or report; short + many → dot-dash memo / lap visual discussed around a table; long + many → slides.
2. Classify the task — the entry mode:

Mode	Input looks like	Entry session
P — Problem-solving	A problem/opportunity to define and analyze; solution not yet found or not yet validated	1 → 2 → 3 → 4 → 5 → 6 → 7 → 8 → 9 → 10
T — Thinking/structuring	Notes, bullet lists, findings, a rambling draft; the thinking exists but is unorganized	3 (top-down; fall back to bottom-up) → 4 → 5 → 6 → 7 → 8 → 9 → 10
C — Communication	The message is already clear; the job is a rigorous document/presentation	3 (fast) → 4 → 5 → 6 → 7 → 8 → 9 → 10
R — Review/repair	An existing document to audit or rewrite	Reverse-engineer its pyramid in 3, then 4–8 as audit gates, 9 rewrite, 10

Mode P additionally routes through the Appendix-A branch inside Session 2 when the situation is structureless (inventing something new, invisible structure, or a structure that fails to explain results). 3. Create the worklog with: mode, reader, medium, one-sentence statement of what the reader should DO or KNOW after reading, the session route, and the bounded input body + its token estimate + the tier it selects (A / B / C per the Execution contract). 4. Hard stop: worklog exists with the above — including the token estimate, without which the run has no budget and no brake. Then open the first routed session file and follow it literally.

Route map

flowchart LR
    IN([input body]) --> S0[0 intake]
    S0 -->|P| S1[1 problem] --> S2[2 analysis] --> S3[3 pyramid]
    S0 -->|T / C / R| S3
    S3 --> S4[4 intros] --> S5[5 logic] --> S6[6 order] --> S7[7 summaries] --> G8{8 GATE}
    G8 -->|fail: owning session| S3
    G8 -->|pass| S9[9 draft] --> S10{10 CRITIQUE}
    S10 -->|defect: owning session| S3
    S10 -->|clean| OUT([deliverable + worklog])

Session index (read the file, then execute; never work from memory of it)

#	Session	File	Source
1	Define the problem	sessions/01-define-problem.md	Ch 8
2	Structure the analysis	sessions/02-structure-analysis.md	Ch 9 + App A
3	Build the pyramid	sessions/03-build-pyramid.md	Ch 1–3
4	Craft the introductions	sessions/04-introductions.md	Ch 4 + App B
5	Horizontal logic: deduction vs induction	sessions/05-deduction-induction.md	Ch 5
6	Impose logical order	sessions/06-logical-order.md	Ch 6
7	Summarize insightfully	sessions/07-summarize-insightfully.md	Ch 7
8	Pre-writing gate	sessions/08-prewriting-gate.md	App C + 30-second test
9	Reflect the pyramid in the output	sessions/09-reflect-output.md	Ch 10–12
10	Post-output critique	sessions/10-post-output-critique.md	Part 2 re-checks + final audit

Non-negotiables carried across all sessions

• Ideas, not categories. Never a heading or bullet called "Background", "Findings", "Introduction", "Issues", "Conclusions" as a structural point (Ch 4 p. 42; Ch 9 p. 161; Ch 10 p. 175).
• No intellectually blank assertions — "There are three problems" tells the kind, not the idea (Ch 7, p. 94).
• News is not thinking. Points that share no subject/predicate/judgment similarity support no inference and get cut (Ch 5, p. 72).
• The introduction reminds, never informs — nothing the reader will question, no exhibits (Ch 4, p. 48).
• Action before argument unless the message is alien to expectations or the reader cannot understand the action without prior reasoning (Ch 5, pp. 65–66).
• Issues are yes/no questions; anything else is a concern (Ch 9, p. 163).
• Alternatives are alternative R2s, not alternative solutions; never raise options merely to knock them down (Ch 4 p. 54; App B p. 225).
• The 30-second test: if the reader cannot get the entire thinking (introduction + main point + key line) in the first 30 seconds, rewrite (Ch 3, p. 29).