# council

> A Claude Code skill from Affaan M's everything-claude-code repo that convenes a four-voice decision council — Architect (in-context), Skeptic, Pragmatist, Critic — for ambiguous decisions with multiple credible paths. The three external voices launch as fresh subagents with only the question and minimal context, anti-anchoring by construction.

**Use case**: Surface structured disagreement before a go / no-go decision, not after

**Canonical URL**: https://agentcookbooks.com/skills/council/

**Topics**: claude-code, skills, agents

**Trigger phrases**: "convene a council on monorepo vs polyrepo", "I need second opinions before deciding", "council: ship now or hold for polish"

**Source**: [Affaan M](https://github.com/affaan-m/everything-claude-code/tree/main/skills/council)

**License**: MIT

---

## What it does

`council` is the decision-making skill in [Affaan M's everything-claude-code](https://github.com/affaan-m/everything-claude-code) — see [skills/council](https://github.com/affaan-m/everything-claude-code/tree/main/skills/council). It convenes four advisors for ambiguous decisions where multiple credible paths exist: the in-context Architect voice (correctness, maintainability, long-term implications), plus three fresh subagents — Skeptic (challenge framing, propose the simplest credible alternative), Pragmatist (shipping speed, operational reality), and Critic (downside risk, edge cases, failure modes).

The anti-anchoring mechanism is structural. The three external voices launch as fresh subagents with *only* the decision question and minimal compact context — not the full conversation transcript. Each gets a strict 4-section response shape: Position (1–2 sentences), Reasoning (3 bullets), Risk (biggest risk in the recommendation), Surprise (one thing the other voices may miss). Under 300 words, no hedging. The Architect writes their position *first*, before reading any external voice, so the synthesis doesn't mirror.

The skill is explicit about when *not* to use it: verifying output correctness (use `santa-method`), breaking a feature into implementation steps (use `planner`), designing system architecture (use `architect`), reviewing code for bugs (use `code-reviewer`). The output shape is a compact verdict with all four positions visible, then a Consensus / Strongest-dissent / Premise-check / Recommendation block. Persistence rules forbid shadow-path notes — if the council changed the recommendation materially, use `knowledge-ops` or `/save-session`; otherwise the decision lives in the conversation and doesn't need a durable artifact.

## When to use it

- Ambiguous decisions with multiple credible paths (monorepo vs polyrepo, ship now vs hold for polish, feature flag vs full rollout)
- The user explicitly asks for second opinions, dissent, or multiple perspectives
- Conversational anchoring is a real risk — the in-context voice has been arguing for one side for many turns
- Go / no-go calls where adversarial challenge sharpens the choice
- Premise-check moments: the Skeptic challenges whether the question itself is the right one

When *not* to reach for it:

- Code review — that's `code-reviewer` or adversarial verification
- Implementation planning — that's `planner`
- Pure factual questions — just answer
- Obvious execution tasks — just do the task
- Every minor decision — convening four voices is overhead the skill is explicit about not wasting

## Install

From [affaan-m/everything-claude-code](https://github.com/affaan-m/everything-claude-code) at `skills/council/`. Drop the folder into `~/.claude/skills/council/`. The skill uses the Agent / Task tool to launch the three external subagents in parallel — no extra MCP server required. The optional integrations the skill calls out (`santa-method` for verification, `knowledge-ops` for durable persistence) are separate skills with their own installs.

## What a session looks like

1. **Extract the real question.** Reduce the decision to one explicit prompt: what are we deciding, what constraints matter, what counts as success? Ask one clarifying question if the framing is vague.
2. **Gather compact context.** Files / snippets / metrics that materially change the answer — keep it tight. The anti-anchoring point evaporates if the subagents get the full transcript.
3. **Architect goes first.** Initial position + three strongest reasons + main risk, written before reading any external voice. This is the no-mirror discipline.
4. **Launch three voices in parallel.** Each gets the question, compact context, role-specific emphasis. Same response shape. Under 300 words each.
5. **Synthesize with bias guardrails.** Don't dismiss an external view without explanation. If an external voice changed the recommendation, say so explicitly. Show the strongest dissent even if rejected. If two voices align against the initial position, that's a real signal.
6. **Emit the compact verdict.** Four positions visible at the top, then Consensus / Strongest-dissent / Premise-check / Recommendation. Scannable on a phone screen.
7. **Persist only if material.** If the council changed the outcome, use `knowledge-ops` or `/save-session` or update the Linear / GitHub issue directly. Don't write ad-hoc notes.

The discipline that makes it work: fresh-subagent isolation. Subagents that share the full transcript will inherit the same anchoring biases as the in-context Architect — they'll politely agree because the conversation primed them. The skill enforces *only-question-and-compact-context* on every external voice so the disagreement is real.

## Receipts

_TODO — to be filled in from a real session. Once the skill has been used on a real ambiguous decision, this section will capture: whether the Skeptic actually challenged the premise (the rarest and most valuable output), which voice surfaced the strongest dissent the Architect hadn't already considered, whether the parallel subagent launch actually ran the three voices independently or one slipped into mirroring the others, and whether the operator's final decision matched the consensus, the dissent, or neither — the third case is the one most worth writing up._

## Source and attribution

From [Affaan M's everything-claude-code](https://github.com/affaan-m/everything-claude-code/tree/main/skills/council) — an MIT-licensed skill collection covering harness construction, agent ops, video, payments, and platform-specific patterns.

License: MIT.

Quoting the value statement verbatim: *"The value is not unanimity. The value is making the disagreement legible before choosing."* That's the wedge — most decision tools optimize for convergence; this one optimizes for surfacing the real disagreement so the operator can see what they're trading off.