/multi-persona-critique

name: multi-persona-critique
description: "Critique a written proposal or design artifact via 5 philosophical personas in parallel, with consensus synthesis."
user-invocable: true
argument-hint: "<proposals to critique, or 'generate N ideas about X'>"
allowed-tools:
  - Read
  - Bash
  - Glob
  - Grep
  - Agent
context: fork
routing:
  triggers:
    - "critique these ideas"
    - "multi-persona review"
    - "philosophical critique"
    - "devil's advocate on ideas"
    - "stress test proposals"
    - "evaluate from multiple perspectives"
    - "get different viewpoints"
    - "critique proposals"
    - "roast code"
    - "devil's advocate"
    - "stress test idea"
    - "roast this"
    - "stress test this idea"
    - "poke holes in this"
  not_for: "speaking to a person, a meeting, or pushing back in a conversation — that is professional-communication. This critiques an artifact, not interpersonal messaging."
  pairs_with:
    - decision-helper
  complexity: Complex
  category: analysis

Multi-Persona Critique: Parallel Philosophical Review of Proposals

Overview

This skill takes a set of proposals — feature ideas, architectural decisions, design choices, strategy options — and sends ALL of them to 5 distinct intellectual personas for parallel, independent critique. Each persona brings a different philosophical lens. The skill then synthesizes all critiques into a consensus report showing where personas agree, where they disagree, and what the disagreements reveal.

**This is NOT the roast skill.** Key differences:

• `roast` critiques CODE with HackerNews personas and validates file:line claims
• This skill critiques IDEAS/PROPOSALS with philosophical/methodological personas and evaluates logical coherence, practical viability, and human impact
• `roast` is evidence-based (checking actual code); this is argument-based (evaluating reasoning)

**Key constraints baked into the workflow:**

• Every persona sees ALL proposals — no cherry-picking
• Personas run in parallel with no awareness of each other — independence is the source of value
• Ratings are mandatory: STRONG / PROMISING / WEAK / REJECT for every proposal from every persona
• Rankings are mandatory: each persona orders proposals from strongest to weakest
• Fairness mandate: genuine strengths must be acknowledged, genuine weaknesses explained with precision
• Disagreements are preserved, not averaged away — the disagreements ARE the insight
• The synthesis phase adds cross-cutting analysis, it does not edit persona outputs

---

Reference Loading Table

| Signal | Load These Files | Why | |---|---|---| | example-driven tasks, errors | `examples-and-errors.md` | Loads detailed guidance from `examples-and-errors.md`. | | dispatching the five critique personas (Phase 2) | `personas.md` | Loads detailed guidance from `personas.md`. | | writing the Phase 5 synthesis report | `synthesis-template.md` | Loads detailed guidance from `synthesis-template.md`. | | roast-style code critique with HN personas | `roast.md` | Loads the roast workflow: evidence-based critique via 5 HN personas with claim validation. | | HN persona specs, claim format, validation verdicts | `hn-personas.md` | Loads HN commenter persona specifications, prompt template, and claim format. |

Instructions

Phase 1: UNDERSTAND PROPOSALS

**Goal**: Extract or generate clear, numbered proposals ready for critique.

**Step 1: Determine input mode**

| Input | Action | |-------|--------| | User provides proposals directly | Extract and number them | | User says "generate N ideas about X" | Research the domain, read relevant code/docs, then generate proposals | | Ambiguous input | Ask user to clarify before proceeding |

**Step 2: Normalize proposals**

Each proposal must be a clear, self-contained description (2-4 sentences) that any of the 5 personas can evaluate independently. If user-provided proposals are vague, expand them to include:

• What the proposal does
• Why it matters (the problem it solves)
• How it differs from the status quo

If generating proposals, research the domain first:

• Use Glob and Grep to understand existing code, docs, and architecture
• Use Read to examine key files relevant to the domain
• Generate proposals grounded in actual context, not hypotheticals

**Step 3: Number and present**

Present the numbered proposal list back to the user before proceeding. Format:

Proposals for critique:
1. [Title] — [2-4 sentence description]
2. [Title] — [2-4 sentence description]
...

**Gate**: Numbered list of proposals ready. Each proposal is self-contained with 2-4 sentences. Proceed only when gate passes.

Phase 2: BRIEF PERSONAS

**Goal**: Construct prompts for each of the 5 personas.

Load the full persona specifications from `${CLAUDE_SKILL_DIR}/references/personas.md`. For each persona, construct a prompt containing an identity block, the numbered proposals, rating and ranking requirements, a fairness mandate, and the structured output format — see `${CLAUDE_SKILL_DIR}/references/examples-and-errors.md` (Phase 2: Persona Prompt Construction) for the complete construction recipe.

**Gate**: 5 persona prompts constructed, each containing all proposals and the full persona specification. Proceed only when gate passes.

Phase 3: DISPATCH (Parallel)

**Goal**: Launch all 5 personas in parallel and collect independent critiques.

Launch 5 agents using the Agent tool, one per persona. Each agent runs independently with no awareness of other personas.

**The 5 parallel agents:**

1. **The Logician** (Bertrand Russell) Focus: Logical coherence, hidden assumptions, falsifiability, necessity vs novelty

2. **The Pragmatic Builder** (20-year staff engineer) Focus: Build cost vs value, maintenance burden, simpler alternatives, user need

3. **The Systems Purist** (Edsger Dijkstra) Focus: Accidental complexity, separation of concerns, elegance, failure modes

4. **The End User Advocate** (8-hours-a-day tool user)