From agent-team-plugin
Facilitates decisions between technical approaches by dispatching advocates to argue cases, gathering codebase context, and synthesizing recommendations with flip conditions.
npx claudepluginhub creator-hian/claude-code-plugins --plugin agent-team-pluginThis skill uses the workspace's default tool permissions.
Help developers make well-reasoned technical decisions fast by having two advocates argue the best case for each option, then synthesizing a fair comparison with a clear recommendation.
Presents structured options with pros, cons, effort, risk, and reversibility trade-offs for informed decision-making between approaches. Use when choosing alternatives.
Analyzes technical decisions like library selections, architecture patterns, and stack choices via multi-agent research, tradeoffs, and two-part executive reports.
Analyzes technical decisions like library selection, architecture patterns, and tech stacks using multi-source research, tradeoff scoring, and conclusion-first reports.
Share bugs, ideas, or general feedback.
Help developers make well-reasoned technical decisions fast by having two advocates argue the best case for each option, then synthesizing a fair comparison with a clear recommendation.
Why this works: When a developer considers "A vs B?", they tend to fixate on the first option they thought of or the one they're more familiar with. By having two independent advocates each build the strongest possible case for their side, the synthesis step gets genuinely balanced arguments to compare — not a biased pro/con list from a single perspective.
Quality target: Every decision must have a clear recommendation with concrete rationale tied to this specific codebase, not generic advice. The flip condition (when you'd choose differently) is as important as the recommendation itself.
Extract the options from the user's request:
If the options are unclear or only one is stated, ask: "What's the alternative you're considering?" Do not proceed with a single option — the skill's value comes from contrast.
Quickly explore the relevant code (Glob, Grep, Read):
Build a decision context (under 800 tokens):
Dispatch 2 agents in a SINGLE response using the Agent tool:
A-Advocate prompt:
You are advocating for [Option A] in a technical decision. Another advocate is simultaneously arguing for the alternative. Your job is to build the strongest possible case for your option — not to be balanced, not to mention downsides, but to be a passionate, well-informed champion.
Your output must contain:
- Core argument — Why this option is the right choice for THIS specific situation (not generic advantages). Reference the codebase context provided.
- Concrete benefits — 3-5 specific advantages, each tied to the current codebase, requirements, or constraints. Be specific: "pairs well with the existing
CacheServiceinsrc/services/cache.ts" not "good performance".- Honest costs — What does this option cost? (complexity, migration effort, learning curve, performance overhead, etc.) Acknowledge the real costs, then explain why they're worth paying. An advocate who hides costs is not credible — an advocate who acknowledges costs and explains why the benefits outweigh them is persuasive.
- Implementation sketch — How this option would look in practice. Key code patterns, file changes, or architecture decisions. Enough detail that someone could start implementing.
- Success scenario — What does the codebase look like 6 months from now if this option is chosen? What becomes easier?
Do NOT critique the alternative. Focus on making the strongest case for YOUR option, including honest acknowledgment of its costs.
You may use Read/Grep/Glob to explore the codebase. Do NOT edit any files. Respond in the same language as the user's request.
B-Advocate prompt: Same structure, advocating for Option B.
Include the decision context in both prompts.
Wait for both advocates to complete before synthesis.
Read both advocate responses. Build a comparison table across these dimensions:
| Dimension | Option A | Option B |
|---|---|---|
| Codebase fit | [how well it fits existing patterns] | [how well it fits] |
| Implementation cost | [effort to implement] | [effort to implement] |
| Long-term impact | [what becomes easier/harder] | [what becomes easier/harder] |
| Risk | [what could go wrong] | [what could go wrong] |
| [domain-specific dimension] | ... | ... |
Add domain-specific dimensions as needed (e.g., "Latency" for a caching decision, "Type safety" for a language feature decision). Only include dimensions where the options meaningfully differ.
Constraint Check — Before making a recommendation, verify:
Make a recommendation:
Write the verdict in this format:
## Decision: [topic]
**Recommendation:** [Option X]
**Confidence:** [Strong / Moderate / Weak]
**Core reason:** [1 sentence]
| Dimension | Option A | Option B |
|-----------|----------|----------|
| ... | ... | ... |
**Constraints verified:** [list each constraint + which option satisfies it]
**Flip condition:** [When to choose the other option]
**Implementation next step:** [The first concrete action to take]
참조:
${CLAUDE_PLUGIN_ROOT}/skills/_shared/logging-protocol.md,${CLAUDE_PLUGIN_ROOT}/skills/_shared/pattern-schema.md
.claude/agent-team/decide/logs/index.json을 읽어 이전 실행 기록 확인 (없으면 디렉토리와 함께 {"entries":[]} 초기화).claude/agent-team/decide/patterns/index.json을 읽어 기존 패턴과 현재 입력 대조 (없으면 건너뜀).md를 읽고 참고, hitCount +1.claude/agent-team/decide/logs/{timestamp}/result.json 작성 (공통 필드 + decide 확장 필드: optionA, optionB, recommendation, confidence, shortcut).claude/agent-team/decide/logs/{timestamp}/summary.md 작성.claude/agent-team/decide/logs/index.json에 entry 추가.claude/agent-team/decide/patterns/로 승격