Skip to main content
Agent skill

Ecc Council

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.

Get started

Get the complete skill folder, including its scripts and reference files.

When to use this skill

Use Ecc Council when an AI agent needs a reusable SKILL.md workflow for this job: 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.

When not to use it

Skip Ecc Council when the task is outside the coding category, or when a more specific skill in this directory already covers the same workflow with clearer triggers.

How to install

Where will you use it?

Install scope
Claude Code folder setup
mkdir -p ~/.claude/skills/ecc-council
# Save SKILL.md to ~/.claude/skills/ecc-council/SKILL.md
  1. Claude Code personal install: place the skill and its bundled files at ~/.claude/skills/ecc-council/SKILL.md. For a shared project, commit the folder at .claude/skills/ecc-council/ instead.
  2. Current Claude Code detects SKILL.md changes in watched directories during the session. If you just created a top-level skills directory, run /reload-skills. Check that the skill is listed before testing its trigger.
  3. For Claude chat or Cowork in the Desktop app, manage uploaded skills in Customize > Skills; copying files into a local Claude Code folder is not a Desktop install. Other agents may use different install locations.

Full install guide for Claude, Cursor, and Codex →

Try a starter prompt

After installing the skill, paste this starter prompt into your agent to verify it triggers on a small task.

Starter prompt
Use the Ecc Council skill for this task: a decision has multiple credible paths and no obvious winner. Confirm any required inputs or files before making changes.

What supports this recommendation?

83/100 provisional content score. This measures documentation, practical detail and source signals. It is not a measured task success rate or a security certification.

Documentation
92/100
Practical detail
92/100
Source evidence
63/100
Source signals
70/100
Model compatibility evidence
  • claudeinferred

    The skill text mentions Claude or a closely associated term. This is keyword-derived compatibility; no hands-on model test is recorded.

  • chatgptuntested

    No model-specific signal or recorded compatibility test was found.

  • geminiuntested

    No model-specific signal or recorded compatibility test was found.

  • copilotuntested

    No model-specific signal or recorded compatibility test was found.

  • llamauntested

    No model-specific signal or recorded compatibility test was found.

  • perplexityuntested

    No model-specific signal or recorded compatibility test was found.

  • mistraluntested

    No model-specific signal or recorded compatibility test was found.

  • grokuntested

    No model-specific signal or recorded compatibility test was found.

Inferred compatibility is based on content signals. Check the app, its available tools and setup requirements before running a skill.

What this skill does

# 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:

```text 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:

```markdown ## 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: - use `knowledge-ops` to store the lesson in the right durable location - or use `/save-session` if the outcome belongs in session memory - or update the relevant GitHub / Linear issue directly if the decision changes active execution truth

Only persist a decision when it changes something real.

## Multi-Round Follow-up

Default is one round.

If the user wants another round: - keep the new question focused - include the previous verdict only if it is necessary - keep the Skeptic as clean as possible to preserve anti-anchoring value

## Anti-Patterns

- using council for code review - using council when the task is just implementation work - feeding the subagents the entire conversation transcript - hiding disagreement in the final verdict - persisting every decision as a note regardless of importance

## Related Skills

- `santa-method` — adversarial verification - `knowledge-ops` — persist durable decision deltas correctly - `search-first` — gather external reference material before the council if needed - `architecture-decision-records` — formalize the outcome when the decision becomes long-lived system policy

## Example

Question:

```text Should we ship ECC 2.0 as alpha now, or hold until the control-plane UI is more complete? ```

Likely council shape: - Architect pushes for structural integrity and avoiding a confused surface - Skeptic questions whether the UI is actually the gating factor - Pragmatist asks what can be shipped now without harming trust - Critic focuses on support burden, expectation debt, and rollout confusion

The value is not unanimity. The value is making the disagreement legible before choosing.

Intended uses

  • 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
  • monorepo vs polyrepo
  • ship now vs hold for polish
  • feature flag vs full rollout
  • simplify scope vs keep strategic breadth

Implementation notes

  • Review the source instructions and adapt inputs before running the workflow.

Try it, then tell us how it went

A copied prompt does not tell us whether the task worked. Report your result after checking the output. We collect your tool and outcome, never your files or prompt.