council

Trigger phrases

Phrases that activate this skill when typed to Claude Code:

• convene a council on monorepo vs polyrepo
• I need second opinions before deciding
• council: ship now or hold for polish

What it does

council is the decision-making skill in Affaan M’s everything-claude-code — see 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 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 — 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.