Skip to content
Skillpedia
Agents280k · #166

council

Gathers a group of models to make difficult decisions. It's useful when there are multiple options and structured analysis is needed.

What it does

Gathers four "voices" (AIs) to help make tough decisions when there are multiple good options and no obvious answer. It ensures different viewpoints are considered before choosing a path.

When to use it

  • ✓Deciding between different paths with similar pros and cons.
  • ✓When you need to understand the risks and benefits of each option.
  • ✓Asking for second opinions or diverse perspectives on a problem.

Example of what to ask your AI

“Should I ship feature X now or wait to polish it more?”

Want more? Open the sections below.

How to use

The easiest way: copy the message below and paste it into Claude, ChatGPT, Cursor or any AI. It reads the skill and follows the instructions.

Skill link

https://github.com/affaan-m/ECC/blob/main/skills/council/SKILL.md

Ready-to-paste message

Use this skill to help me: https://github.com/affaan-m/ECC/blob/main/skills/council/SKILL.md Read the SKILL.md file at that link and follow its instructions for my task.
How it works

The AI takes on four roles: a main voice (Architect), a Skeptic, a Pragmatist, and a Critic. Each analyzes the problem from their unique perspective, and the AI then synthesizes these opinions to present a final recommendation.

Installation

Easiest way: copy the skill link and paste it into Claude, ChatGPT or Cursor asking it to follow the instructions.

In the terminal (Claude Code, Codex, Cursor), in your project folder:

npx skills add affaan-m/ECC --skill council

Or download just the file:

curl -L https://raw.githubusercontent.com/affaan-m/ECC/main/skills/council/SKILL.md -o SKILL.md
Technical content (original SKILL.md)

Original text by the author, straight from GitHub.

Council

Convene four advisors for ambiguous decisions:

  • the in-context Claude voice
  • a Skeptic subagent
  • a Pragmatist subagent
  • a Critic subagent

This is for decision-making under ambiguity, not code review, implementation planning, or architecture design.

When to Use

Use council when:

  • a decision has multiple credible paths and no obvious winner
  • you need explicit tradeoff surfacing
  • the user asks for second opinions, dissent, or multiple perspectives
  • conversational anchoring is a real risk
  • a go / no-go call would benefit from adversarial challenge

Examples:

  • monorepo vs polyrepo
  • ship now vs hold for polish
  • feature flag vs full rollout
  • simplify scope vs keep strategic breadth

When NOT to Use

Instead of council Use
Verifying whether output is correct santa-method
Breaking a feature into implementation steps planner
Designing system architecture architect
Reviewing code for bugs or security code-reviewer or santa-method
Straight factual questions just answer directly
Obvious execution tasks just do the task

Roles

Voice Lens
Architect correctness, maintainability, long-term implications
Skeptic premise challenge, simplification, assumption breaking
Pragmatist shipping speed, user impact, operational reality
Critic edge cases, downside risk, failure modes

The three external voices should be launched as fresh subagents with only the question and relevant context, not the full ongoing conversation. That is the anti-anchoring mechanism.

Workflow

1. Extract the real question

Reduce the decision to one explicit prompt:

  • what are we deciding?
  • what constraints matter?
  • what counts as success?

If the question is vague, ask one clarifying question before convening the council.

2. Gather only the necessary context

If the decision is codebase-specific:

  • collect the relevant files, snippets, issue text, or metrics
  • keep it compact
  • include only the context needed to make the decision

If the decision is strategic/general:

  • skip repo snippets unless they materially change the answer

3. Form the Architect position first

Before reading other voices, write down:

  • your initial position
  • the three strongest reasons for it
  • the main risk in your preferred path

Do this first so the synthesis does not simply mirror the external voices.

4. Launch three independent voices in parallel

Each subagent gets:

  • the decision question
  • compact context if needed
  • a strict role
  • no unnecessary conversation history

Prompt shape:

You are the [ROLE] on a four-voice decision council.

Question:
[decision question]

Context:
[only the relevant snippets or constraints]

Respond with:
1. Position — 1-2 sentences
2. Reasoning — 3 concise bullets
3. Risk — biggest risk in your recommendation
4. Surprise — one thing the other voices may miss

Be direct. No hedging. Keep it under 300 words.

Role emphasis:

  • Skeptic: challenge framing, question assumptions, propose the simplest credible alternative
  • Pragmatist: optimize for speed, simplicity, and real-world execution
  • Critic: surface downside risk, edge cases, and reasons the plan could fail

5. Synthesize with bias guardrails

You are both a participant and the synthesizer, so use these rules:

  • do not dismiss an external view without explaining why
  • if an external voice changed your recommendation, say so explicitly
  • always include the strongest dissent, even if you reject it
  • if two voices align against your initial position, treat that as a real signal
  • keep the raw positions visible before the verdict

6. Present a compact verdict

Use this output shape:

## Council: [short decision title]

**Architect:** [1-2 sentence position]
[1 line on why]

**Skeptic:** [1-2 sentence position]
[1 line on why]

**Pragmatist:** [1-2 sentence position]
[1 line on why]

**Critic:** [1-2 sentence position]
[1 line on why]

### Verdict
- **Consensus:** [where they align]
- **Strongest dissent:** [most important disagreement]
- **Premise check:** [did the Skeptic challenge the question itself?]
- **Recommendation:** [the synthesized path]

Keep it scannable on a phone screen.

Persistence Rule

Do not write ad-hoc notes to ~/.claude/notes or other shadow paths from this skill.

If the council materially changes the recommendation:

…

FAQ

What are the four roles for?

The Architect focuses on correctness and long-term. The Skeptic questions assumptions. The Pragmatist focuses on speed and reality. The Critic points out risks and failures.

When should I NOT use this tool?

Don't use it for code review, implementation planning, architecture design, or simple factual questions. Other tools are better suited for those tasks.

How does the AI prevent one opinion from dominating others?

The other three voices are started independently, receiving only the question and necessary context, without knowing what others said or the prior conversation. This prevents opinions from influencing each other (anchoring).

Details

Original description by the author

Convene a four-voice council for ambiguous decisions, tradeoffs, and go/no-go calls. Use when multiple valid paths exist and you need structured disagreement before choosing.

repo: affaan-m/ECC

Popularity

GitHub stars
280k
Ranking position
#166
License
MIT
Updated
10/15/2026

Is this skill useful?

0

Sign in to vote.

Comments

  • …

More skills from this repository

Similar skills