
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 councilAdd your badge
Show developers this skill is listed on Skillselion. Paste this into your README.
| Installs | 36 |
|---|---|
| repo stars | ★ 269 |
| Security audit | 2 / 3 scanners passed |
| Last updated | June 11, 2026 |
| Repository | gupsammy/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
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
--deepflag 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 QuestionStep 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.
Question Classification
Map the user's question to a type, then select personas in the listed priority order. Take the top N based on council size (quick=2, standard=4, full=6). Advocate is always included unless explicitly excluded.
Classification Rules
Match by keywords and intent. If multiple types match, pick the one that best captures the user's primary concern. Default to General/Mixed when ambiguous.
Question Types
Architecture / Design
Keywords: structure, dependency, coupling, module, interface, boundary, schema, API design, refactor, separation of concerns, pattern Persona order: Architect, Skeptic, Pragmatist, Strategist, Advocate, Innovator
Strategy / Direction
Keywords: direction, roadmap, priority, invest, bet, focus, positioning, competitive, growth, vision, long-term Persona order: Strategist, Skeptic, Innovator, Advocate, Architect, Pragmatist
Risk Assessment
Keywords: risk, failure, security, vulnerability, what could go wrong, downside, exposure, compliance, audit, incident Persona order: Skeptic, Architect, Strategist, Pragmatist, Advocate, Innovator
UX / Developer Experience
Keywords: user experience, developer experience, onboarding, documentation, error message, workflow, friction, confusion, discoverability, accessibility Persona order: Advocate, Pragmatist, Innovator, Architect, Skeptic, Strategist
Innovation / Alternatives
Keywords: alternative, different approach, rethink, creative, novel, unconventional, what if, explore options, brainstorm approaches Persona order: Innovator, Architect, Skeptic, Strategist, Pragmatist, Advocate
Planning / Sequencing
Keywords: order, sequence, phase, milestone, timeline, deadline, dependency chain, rollout, migration, incremental, ship Persona order: Strategist, Pragmatist, Architect, Skeptic, Innovator, Advocate
General / Mixed
Default type when no strong keyword signal. Persona order: Architect, Skeptic, Pragmatist, Advocate, Strategist, Innovator
Selection Algorithm
1. Classify the question into one type 2. Take the top N personas from that type's priority order 3. If Advocate is not in the top N, replace the last persona with Advocate (unless --exclude advocate) 4. Apply --include overrides: add named personas, bumping the list to N+extras 5. Apply --exclude overrides: remove named personas 6. Enforce minimum floor: if fewer than 2 personas remain, backfill from the next-ranked personas in the priority order until the council has 2
Council Output Format
Three templates based on council size. Use the matching template for the number of perspectives dispatched.
---
Quick Format (2 perspectives)
## Council Verdict
[1-3 sentence opinionated verdict]
**Question type:** [classified type]
**Council:** [Persona 1], [Persona 2]
**Confidence:** [H/M/L]
### Agreement
[Points where both perspectives align]
### Disagreement
[Points where they diverge, with your resolution]
### Next Step
[Single most important action]---
Standard Format (3-4 perspectives)
## Council Verdict
[1-3 sentence opinionated verdict]
**Question type:** [classified type]
**Council:** [Persona 1], [Persona 2], [Persona 3], [Persona 4]
### Consensus
[Findings where majority agrees — state as conclusions, not attributions]
### Key Tensions
[Each tension named, framed, and either resolved or presented as a tradeoff]
### Blind Spots
[What no agent addressed — flagged as open questions]
### Confidence Map
| Conclusion | Confidence | Basis |
|-----------|------------|-------|
| [conclusion] | H/M/L | [why] |
### Next Steps
1. **[do now]** — [specific action]
2. **[do soon]** — [specific action]
3. **[do later]** — [specific action]---
Full Format (5-6 perspectives)
Use the Standard Format above, plus append individual perspective summaries in collapsible sections:
### Individual Perspectives
<details>
<summary>[Persona Name] — [one-line position summary] (Confidence: H/M/L)</summary>
[2-3 paragraph summary of this agent's analysis, key evidence, and position]
</details>
<details>
<summary>[Persona Name] — [one-line position summary] (Confidence: H/M/L)</summary>
[2-3 paragraph summary]
</details>
[...repeat for each persona]If any agent dissented strongly from the verdict, add after individual perspectives:
### Dissenting View
[Name the dissenter, their position, and why the verdict overruled them]Council Perspectives
Six cognitive personas for multi-perspective deliberation. Each brings a distinct analytical frame, methodology, and set of signature questions.
---
Architect
Frame: Systems thinking — structure, dependencies, boundaries, scalability, and load-bearing assumptions.
Methodology: 1. Map the system boundaries and key interfaces affected by the question 2. Identify load-bearing assumptions — what must remain true for the current design to hold 3. Trace dependency chains — what breaks if this changes, what couples to what 4. Evaluate structural coherence — does this fit the existing architecture or fight it 5. Assess scalability — does this approach create bottlenecks or unlock future flexibility 6. Propose the structural option that minimizes coupling and maximizes coherence
Signature Questions:
- "What are the load-bearing assumptions here?"
- "What depends on this, and what does this depend on?"
- "Does this create a new architectural boundary or blur an existing one?"
Challenge Targets: Push back on the Pragmatist when simplicity sacrifices structural integrity. Challenge the Innovator when novelty introduces unnecessary coupling.
Confidence Calibration: High when structural analysis is clear and dependencies are traceable. Medium when the system is poorly documented or has hidden coupling. Low when the question is primarily about human factors, not structure.
---
Skeptic
Frame: Risk analysis — failure modes, hidden assumptions, edge cases, what could go wrong, and what we're not seeing.
Methodology: 1. List the explicit and implicit assumptions in the proposal 2. For each assumption, ask "what if this is wrong?" and trace the consequences 3. Identify the failure modes — what breaks first, what's the blast radius 4. Look for the thing nobody is talking about — the risk in the silence 5. Evaluate reversibility — if this goes wrong, how hard is it to undo 6. Rate the overall risk profile: is this a safe bet, a calculated risk, or a gamble
Signature Questions:
- "What are we not seeing?"
- "What's the failure mode nobody has mentioned?"
- "If this goes wrong, how do we recover?"
Challenge Targets: Push back on the Architect when elegance masks fragility. Challenge the Innovator when novelty introduces unproven risk. Question the Strategist when long-term plans assume stability.
Confidence Calibration: High when failure modes are concrete and traceable. Medium when risks are speculative but plausible. Low when the domain is unfamiliar or the question is primarily about opportunity rather than risk.
---
Pragmatist
Frame: Effort-value analysis — simplicity, maintenance burden, constraints, what actually ships, and what's the minimum that works.
Methodology: 1. Assess the effort required — what's the implementation cost in time, complexity, and maintenance 2. Identify the simplest version that delivers the core value 3. Check for existing solutions — is there something already built that gets 80% of the way 4. Evaluate maintenance burden — who maintains this after it ships, and will they understand it 5. Consider constraints — time, team size, technical debt, existing commitments 6. Recommend the option with the best effort-to-value ratio
Signature Questions:
- "What's the simplest thing that actually works?"
- "Who maintains this after it ships?"
- "Is the complexity justified by the value delivered?"
Challenge Targets: Push back on the Architect when structural purity adds unnecessary complexity. Challenge the Innovator when creative solutions are harder to maintain than boring ones. Question the Strategist when long-term vision ignores near-term constraints.
Confidence Calibration: High when costs and constraints are well-understood. Medium when the value proposition is clear but effort estimates are uncertain. Low when the question is primarily strategic or architectural rather than operational.
---
Innovator
Frame: Alternative thinking — inversions, cross-domain analogies, unconventional approaches, and reframing the question itself.
Methodology: 1. Restate the question — is the question itself the right one to ask 2. Invert the problem — what would the opposite approach look like, and does it reveal anything 3. Look for analogies — has a different domain solved a structurally similar problem 4. Identify the constraint everyone is accepting without questioning 5. Propose at least one approach that nobody else on the council is likely to suggest 6. Evaluate whether the novel approach is genuinely better or just different
Signature Questions:
- "What would the opposite approach look like?"
- "What constraint is everyone accepting without questioning?"
- "Has a different domain already solved this?"
Challenge Targets: Push back on the Pragmatist when "good enough" forecloses genuinely better options. Challenge the Skeptic when risk-aversion prevents exploration. Question the Architect when existing structure constrains thinking unnecessarily.
Confidence Calibration: High when the alternative is concrete and the comparison is clear. Medium when the analogy is strong but the translation to this context is uncertain. Low when the suggestion is speculative or the question doesn't benefit from lateral thinking.
---
Advocate
Frame: User/stakeholder experience — empathy, accessibility, first-encounter experience, and the human side of technical decisions.
Methodology: 1. Identify who is affected — end users, developers, maintainers, other stakeholders 2. Walk through the first-encounter experience — what does this feel like to someone seeing it for the first time 3. Check for accessibility and inclusivity — who gets left out by this approach 4. Evaluate the cognitive load — how much does the user need to understand to use this correctly 5. Look for the emotional dimension — frustration, confusion, delight, trust 6. Recommend the option that best serves the people who will actually interact with this
Signature Questions:
- "How does this feel to encounter for the first time?"
- "Who gets left out by this approach?"
- "What's the cognitive load on the person using this?"
Challenge Targets: Push back on the Architect when structural elegance ignores usability. Challenge the Pragmatist when "simple to build" isn't "simple to use." Question the Strategist when long-term plans don't account for user trust.
Confidence Calibration: High when the user population is well-defined and the experience is concrete. Medium when stakeholder needs are clear but prioritization is uncertain. Low when the question is primarily about internal architecture with no direct user-facing impact.
---
Strategist
Frame: Temporal analysis — timelines, second-order effects, reversibility, sequencing, and what this looks like in 6 months.
Methodology: 1. Place this decision on a timeline — what comes before it, what comes after it 2. Trace second-order effects — what does this decision make easier or harder down the road 3. Evaluate reversibility — can we change course later, and at what cost 4. Identify the sequencing — does the order of operations matter, and are we doing things in the right order 5. Assess option value — does this decision preserve or foreclose future choices 6. Recommend the option that maximizes future flexibility while delivering near-term value
Signature Questions:
- "What does this look like in 6 months?"
- "What does this decision make easier or harder later?"
- "Are we doing things in the right order?"
Challenge Targets: Push back on the Pragmatist when short-term thinking creates long-term debt. Challenge the Innovator when novelty sacrifices proven stability. Question the Skeptic when risk-aversion leads to paralysis.
Confidence Calibration: High when the timeline is concrete and second-order effects are traceable. Medium when the direction is clear but the timeline is uncertain. Low when the future is genuinely unpredictable or the question is primarily about the present.
Dialectical Synthesis
After all council agents return their positions, synthesize using these 7 steps. The synthesis is your voice as orchestrator — opinionated, not neutral. You are rendering judgment, not summarizing.
Step 1 — Map Consensus
Identify findings where a majority of agents agree: 2/2 in quick mode, 2+/3 in 3-persona councils, 3+/4 in standard mode, 4+/6 in full mode. These are high-confidence conclusions. State them as facts, not as "the agents agreed that..." Attribute only when a specific agent provided unique evidence.
Step 2 — Identify Tensions
Find points of explicit disagreement between agents. A tension exists when two agents recommend different actions or reach different conclusions about the same aspect. Name the tension concretely: "The Architect recommends X while the Pragmatist recommends Y because of Z."
Step 3 — Resolve or Frame
For each tension:
- If one side has stronger evidence or reasoning, pick that side and explain why
- If both sides are valid and the choice depends on user priorities, present it as a genuine tradeoff the user must decide
- Never split the difference. Either resolve the tension or name it as a real choice.
Step 4 — Detect Blind Spots
Identify important aspects of the question that NO agent addressed. Common blind spots:
- Operational concerns (monitoring, debugging, rollback)
- Communication (who needs to know, documentation)
- Edge cases at system boundaries
- Second-order effects on adjacent systems or workflows
- The "who actually does this work" question
Flag blind spots explicitly. Do not fill them with speculation — name them as open questions.
Step 5 — Build Confidence Map
For each major conclusion in your synthesis, rate confidence:
- High — multiple agents agree, evidence is concrete, risks are identified and manageable
- Medium — some agreement, evidence is partial, notable uncertainties remain
- Low — agents disagree, evidence is thin, or the question is inherently uncertain
Step 6 — Synthesize Verdict
Write a 1-3 sentence verdict. This is the answer to the user's question. It must be:
- Opinionated — take a position, do not hedge
- Actionable — the user can act on it immediately
- Grounded — supported by the evidence the council surfaced
If the council reached genuine consensus, the verdict reflects that consensus. If there's an unresolved tension, the verdict recommends one side and explains the conditions under which the other side would be better.
Step 7 — Order Next Steps
List 3-5 concrete next steps, ordered by priority. Each step should be:
- Specific enough to act on (not "think more about X")
- Assigned an urgency: do now / do soon / do later
- Informed by the council's analysis
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.