Now liveThe Skillselion MCP - thousands of ranked skills, loaded into your agent mid-task. No install.Get it →
gupsammy avatar

Council

  • 36 installs
  • 269 repo stars
  • Updated June 11, 2026
  • gupsammy/claudest

Council is an agent skill that classifies your question and convenes ordered expert personas—usable whenever a solo builder needs multi-angle debate before committing to design, strategy, or risk calls.

About

Council is a journey-wide Claude-oriented skill that turns fuzzy builder questions into a typed deliberation: you classify the user’s concern, then summon a ordered set of personas to argue from complementary angles. Architecture and design questions prioritize Architect and Skeptic; strategy and roadmap bets lead with Strategist; risk and security lean Skeptic-first; UX and developer experience foreground Advocate; innovation prompts elevate Innovator. Quick, standard, and full council sizes control cost and depth while keeping Advocate in the room unless you explicitly drop it. For solo and indie operators wearing every hat, the skill is procedural insurance against one-voice overconfidence—you get structured disagreement and pragmatic pushback before you refactor, reposition, or ship. Use it whenever a decision has tradeoffs that deserve more than a single chat reply, from API boundaries to growth bets to incident postmortems.

  • Keyword-driven question classification into architecture, strategy, risk, UX, and innovation buckets
  • Fixed persona roster: Architect, Skeptic, Pragmatist, Strategist, Advocate, Innovator with per-type priority order
  • Council sizes: quick (2), standard (4), full (6) personas with Advocate included by default
  • Defaults to General/Mixed when intent is ambiguous instead of forcing a wrong specialty lane
  • Designed for agent sessions that simulate a leadership council rather than a single generic assistant voice

Council by the numbers

  • 36 all-time installs (skills.sh)
  • Ranked #8,638 of 16,546 AI & Agent Building skills by installs in the Skillselion catalog
  • Security screen: HIGH risk (skills.sh audit)
  • Data as of Aug 4, 2026 (Skillselion catalog sync)
npx skills add https://github.com/gupsammy/claudest --skill council

Add your badge

Show developers this skill is listed on Skillselion. Paste this into your README.

Listed on Skillselion
Installs36
repo stars269
Security audit2 / 3 scanners passed
Last updatedJune 11, 2026
Repositorygupsammy/claudest

What it does

Run a structured multi-persona deliberation so one developer hears architect, skeptic, strategist, and advocate angles before committing to a technical or product decision.

Who is it for?

Best when you're deciding architecture, roadmap bets, risk posture, UX friction, or unconventional approaches and want deliberate role-played perspectives in one session.

Skip if: Pure execution tasks with an already-approved spec, or situations where you need live data pulls and tool execution instead of deliberation.

When should I use this skill?

The user faces an ambiguous architecture, strategy, risk, UX, or innovation decision and needs ordered multi-persona debate rather than a single generic answer.

What you get

You receive a council-shaped answer with personas matched to your question type and council size, so tradeoffs are visible before you implement or pivot.

  • Question type classification
  • Ordered persona council response with competing viewpoints

By the numbers

  • 6 named personas in the roster
  • 5 primary question-type lanes plus General/Mixed default
  • 3 council sizes: quick=2, standard=4, full=6

Files

SKILL.mdMarkdownGitHub ↗

Council

Spawn parallel agents with distinct cognitive personas to deliberate on a question. Each agent investigates relevant files before forming a position. Synthesize into an opinionated verdict.

Value Context

Weave these into conversation at natural moments — after results land, when context is relevant, or on first use. One or two per run, not all at once.

  • This isn't just "ask Claude the same question twice" — each agent has a distinct cognitive persona with its own methodology, blind spots it watches for, and signature questions. The disagreements between them are the most valuable output.
  • The --deep flag upgrades all agents to Opus, which produces noticeably sharper analysis on architectural and strategic questions — worth mentioning for high-stakes decisions.
  • Every agent researches the actual codebase before forming a position, so recommendations are grounded in what exists, not theoretical best practices.
  • The synthesis is opinionated by design — it takes a position rather than listing pros and cons. Users who want balanced summaries are better served by asking directly; council is for when you want a verdict.

Step 1 — Parse Input

Extract the question from $ARGUMENTS. Parse flags:

  • --quick → 2 perspectives
  • (default, no flag) → 4 perspectives
  • --full → all 6 perspectives
  • --deep → use Opus model for spawned agents (orchestrator model unchanged)
  • --include name,name → force-include specific personas
  • --exclude name,name → force-exclude specific personas

If $ARGUMENTS is empty or too vague to classify, use AskUserQuestion to ask the user what question they want the council to deliberate on.

Step 2 — Classify Question

Load @references/classification.md. Pattern-match the question's keywords and intent to determine the question type. Default to General/Mixed if ambiguous.

Step 3 — Select Personas

From @references/classification.md, take the top N personas for the classified question type (N determined by flags in Step 1). Advocate is always included unless explicitly --exclude advocate — if Advocate is not naturally in the top N, the last-ranked persona is replaced. Apply any --include/--exclude overrides. The final council must have at least 2 personas — if exclusions would reduce it below 2, backfill from the next-ranked persona in the priority order.

Announce to the user:

  • The classified question type
  • Which council members are participating (name + one-line frame)
  • Council size (quick/standard/full)

Keep the announcement to 3-4 lines. Do not reproduce full persona definitions.

Step 4 — Build Agent Prompts

For each selected persona, load its full definition from @references/perspectives.md. Build the agent prompt with this structure:

You are the [PERSONA NAME] on a deliberation council.

[Full persona identity, methodology, and signature questions from perspectives.md]

## Your Task

Deliberate on this question: "[USER'S QUESTION]"

## Research First

Before forming your position, use Read, Glob, and Grep to investigate relevant files in the codebase that inform this question. Look at configs, docs, existing code, tests, and any prior art. Ground your analysis in what actually exists, not assumptions.

## Output Requirements

- 300-500 words
- State your position clearly in the first sentence
- Support with specific evidence (file paths, code patterns, concrete examples)
- Rate your confidence: High / Medium / Low
- End with your signature question applied to this specific context
- Structure: Position → Evidence → Risks/Tradeoffs → Confidence → Signature Question

Step 5 — Spawn Agents

Launch ALL agent calls in a single message so they run in parallel. Use the Agent tool with:

  • subagent_type: "general-purpose"
  • model: "sonnet" (default) or "opus" (if --deep)
  • description: "[Persona Name] perspective"
  • prompt: the full prompt built in Step 4

Do NOT spawn them sequentially. All agents MUST be launched in one message for parallel execution.

Step 6 — Synthesize

After all agents return, follow the dialectical synthesis methodology in @references/synthesis.md:

1. Map consensus — findings where majority of agents agree 2. Identify tensions — points of explicit disagreement between agents 3. Resolve or frame tensions — pick a side with reasoning, or present as genuine tradeoff the user must decide 4. Detect blind spots — important aspects no agent addressed 5. Build confidence map — aggregate confidence ratings per conclusion 6. Synthesize verdict — an opinionated recommendation, not a neutral summary 7. Order next steps — 3-5 concrete actions ranked by priority

The synthesis is YOUR voice as orchestrator, not a recap of what agents said. Be opinionated. Take a position. The council provided input; you provide the judgment.

Step 7 — Output Report

Format the report using the template from @references/output-format.md that matches the council size:

  • Quick (2 perspectives) → compact format
  • Standard (3-4 perspectives) → full format
  • Full (5-6 perspectives) → full format with individual perspectives in collapsible sections

After delivering the report, ask the user if they want to act on the top recommendation.

Related skills

How it compares

Use instead of a single-pass chat opinion when you want repeatable persona ordering—not a code generator or automated security scanner.

FAQ

Who is council for?

Developers using Claude-style agents who want architect, skeptic, and strategist voices on hard decisions without hiring a formal committee.

When should I use council?

At idea/research for strategy and architecture framing; at validate/scope for risk and positioning; at build/integrations for API and module boundaries; at ship/security for failure modes; at launch/distribution for competitive bets—whenever tradeoffs deserve multiple stances.

Is council safe to install?

Council is deliberation guidance; check the Security Audits panel on this Prism page and avoid piping secrets into multi-persona transcripts you do not want logged.

AI & Agent Buildingagentsautomation

This week in AI coding

Five minutes, every Monday - the tools, releases and tactics for developers.

unsubscribe anytime.