feature-council
Compare original and translation side by side
🇺🇸
Original
English🇨🇳
Translation
ChineseFeature Council: Multi-Agent Feature Implementation
Feature Council：多Agent功能实现
Spawns multiple agents to implement the same feature independently, then synthesizes the best parts from each. Unlike code-council (majority voting for bugs), this skill merges strengths because features have multiple valid approaches.
Use this for complex features where you want diverse implementations and comprehensive coverage.
生成多个Agent独立实现同一功能，然后整合各实现中的最优部分。与code-council（针对Bug的多数投票机制）不同，该技能会融合各Agent的优势，因为功能实现存在多种有效方案。
适用于需要多样化实现方案和全面覆盖的复杂功能场景。
Step 0: Ask User How Many Agents
步骤0：询问用户使用的Agent数量
Before doing anything else, ask the user how many solver agents to use:
How many solver agents would you like me to use? (3-10)
Recommendations:
- 3 agents: Faster, good for straightforward features
- 5 agents: Good balance of diversity and speed
- 7 agents: Comprehensive coverage
- 10 agents: Maximum diversity (complex features)
Note: Each agent will independently implement the entire feature.
More agents = more diverse approaches and edge case coverage.Wait for the user's response. If they specified a number (e.g., "feature council of 5"), use that.
Minimum: 3 agents | Maximum: 10 agents
在执行任何操作前，询问用户需要使用的求解Agent数量：
How many solver agents would you like me to use? (3-10)
Recommendations:
- 3 agents: Faster, good for straightforward features
- 5 agents: Good balance of diversity and speed
- 7 agents: Comprehensive coverage
- 10 agents: Maximum diversity (complex features)
Note: Each agent will independently implement the entire feature.
More agents = more diverse approaches and edge case coverage.等待用户回复。如果用户指定了数量（例如“feature council of 5”），则使用该数量。
最低：3个Agent | 最高：10个Agent
CRITICAL: Pure Independence
核心要求：完全独立
What This Means
具体含义
- NO orchestrator exploration - Do NOT read files or gather context before spawning agents
- Raw user prompt to all agents - Each agent gets the user's original request, unchanged
- Each agent explores independently - Agents discover the codebase themselves
- Each agent implements fully - Complete, working implementations
- 禁止编排器预探索 - 在生成Agent前，不要读取文件或收集上下文信息
- 原始用户请求直接发给所有Agent - 每个Agent收到的都是未修改的原始用户请求
- 每个Agent独立探索 - Agent自行探索代码库
- 每个Agent完整实现功能 - 产出可运行的完整实现方案
Why This Matters
重要性
Independent implementations mean:
- Different architectural choices to compare
- Different edge cases discovered
- Different error handling approaches
- More comprehensive final solution
独立实现意味着：
- 可对比不同的架构选择
- 能发现不同的边缘场景
- 可采用不同的错误处理方案
- 最终方案更全面
Workflow
工作流程
Step 1: Capture the Raw User Prompt
步骤1：捕获原始用户请求
Take the user's request exactly as stated. Do NOT:
- ❌ Read files first
- ❌ Explore the codebase
- ❌ Add context
- ❌ Rephrase or enhance the prompt
Just capture what the user said.
原样记录用户的请求。禁止：
- ❌ 先读取文件
- ❌ 探索代码库
- ❌ 添加上下文
- ❌ 改写或优化请求
只需记录用户的原始表述。
Step 2: Spawn Agents IN PARALLEL with RAW PROMPT
步骤2：并行生成Agent并下发原始请求
Spawn ALL agents simultaneously. Each gets the exact same raw prompt:
Task(agent: "feature-solver-1", prompt: "[USER'S EXACT WORDS]")
Task(agent: "feature-solver-2", prompt: "[USER'S EXACT WORDS]")
Task(agent: "feature-solver-3", prompt: "[USER'S EXACT WORDS]")
... (all in the SAME batch - parallel execution)DO NOT modify the prompt. DO NOT add context. Raw user words only.
同时生成所有Agent。每个Agent收到完全相同的原始请求：
Task(agent: "feature-solver-1", prompt: "[USER'S EXACT WORDS]")
Task(agent: "feature-solver-2", prompt: "[USER'S EXACT WORDS]")
Task(agent: "feature-solver-3", prompt: "[USER'S EXACT WORDS]")
... (all in the SAME batch - parallel execution)禁止修改请求，禁止添加上下文，仅下发用户原始表述。
Step 3: Agents Work Independently
步骤3：Agent独立工作
Each agent will:
- Read and understand the user's feature request
- Explore the codebase to understand existing patterns
- Design their approach
- Implement the complete feature
- Handle edge cases they identify
- Verify their implementation
Each agent works in complete isolation.
每个Agent会：
- 读取并理解用户的功能需求
- 探索代码库以理解现有模式
- 设计实现方案
- 完成功能的完整实现
- 处理其识别到的边缘场景
- 验证实现方案
每个Agent完全独立工作。
Step 4: Track Progress & Collect Solutions
步骤4：跟踪进度并收集实现方案
As agents complete, show progress to the user:
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
AGENT PROGRESS
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
☑ Agent 1 - Complete
☑ Agent 2 - Complete
☑ Agent 3 - Complete
☐ Agent 4 - Working...
☐ Agent 5 - Working...
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━Collect all outputs when complete.
当Agent完成任务时，向用户展示进度：
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
AGENT PROGRESS
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
☑ Agent 1 - Complete
☑ Agent 2 - Complete
☑ Agent 3 - Complete
☐ Agent 4 - Working...
☐ Agent 5 - Working...
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━所有Agent完成后，收集全部产出。
Step 5: Analyze & Compare Implementations
步骤5：分析与对比实现方案
DO NOT use majority voting. Instead, analyze each implementation for:
| Category | What to Look For |
|---|---|
| Architecture | Design patterns, code organization, modularity |
| Edge Cases | What edge cases did each agent handle? |
| Error Handling | How robust is the error handling? |
| Type Safety | Type definitions, null checks, validation |
| Performance | Efficiency, caching, optimization |
| Maintainability | Readability, documentation, testability |
| Codebase Fit | How well does it match existing patterns? |
Create a comparison matrix:
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
IMPLEMENTATION COMPARISON
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
| Aspect | Agent 1 | Agent 2 | Agent 3 | Agent 4 | Agent 5 |
|-----------------|---------|---------|---------|---------|---------|
| Architecture | MVC | Service | MVC | MVC | Modular |
| Edge Cases | 3 | 5 | 4 | 3 | 6 |
| Error Handling | Basic | Robust | Good | Basic | Robust |
| Type Safety | ✓ | ✓✓ | ✓ | ✓ | ✓✓ |
| Codebase Match | 90% | 75% | 95% | 85% | 80% |
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━禁止使用多数投票机制。应从以下维度分析每个实现方案：
| 维度 | 评估要点 |
|---|---|
| 架构设计 | 设计模式、代码组织、模块化程度 |
| 边缘场景 | 每个Agent处理了哪些边缘场景？ |
| 错误处理 | 错误处理的健壮性如何？ |
| 类型安全 | 类型定义、空值检查、验证逻辑 |
| 性能表现 | 效率、缓存机制、优化措施 |
| 可维护性 | 可读性、文档、可测试性 |
| 代码库适配度 | 与现有代码模式的匹配程度？ |
创建对比矩阵：
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
IMPLEMENTATION COMPARISON
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
| Aspect | Agent 1 | Agent 2 | Agent 3 | Agent 4 | Agent 5 |
|-----------------|---------|---------|---------|---------|---------|
| Architecture | MVC | Service | MVC | MVC | Modular |
| Edge Cases | 3 | 5 | 4 | 3 | 6 |
| Error Handling | Basic | Robust | Good | Basic | Robust |
| Type Safety | ✓ | ✓✓ | ✓ | ✓ | ✓✓ |
| Codebase Match | 90% | 75% | 95% | 85% | 80% |
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━Step 6: Synthesize Best Solution
步骤6：合成最优方案
Combine the best elements from each agent:
- Select base implementation - Choose the one that best matches codebase patterns
- Incorporate edge cases - Add edge cases from other agents the base missed
- Enhance error handling - Use the most robust error handling approach
- Improve type safety - Merge type definitions and validations
- Document sources - Track which elements came from which agent
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
SYNTHESIS DECISION
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Base: Agent 3 (best codebase pattern match)
Incorporating from other agents:
├─ Agent 2: Robust error handling pattern
├─ Agent 5: Edge cases for [empty input, concurrent access]
├─ Agent 2: Type definitions for [UserInput, ValidationResult]
└─ Agent 4: Caching optimization
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━整合每个Agent实现中的最优元素：
- 选择基础实现方案 - 选择与代码库模式匹配度最高的实现作为基础
- 补充边缘场景处理 - 添加基础方案遗漏的、其他Agent覆盖的边缘场景
- 增强错误处理 - 采用最健壮的错误处理方案
- 提升类型安全 - 合并各Agent的类型定义与验证逻辑
- 记录来源 - 跟踪每个元素来自哪个Agent
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
SYNTHESIS DECISION
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Base: Agent 3 (best codebase pattern match)
Incorporating from other agents:
├─ Agent 2: Robust error handling pattern
├─ Agent 5: Edge cases for [empty input, concurrent access]
├─ Agent 2: Type definitions for [UserInput, ValidationResult]
└─ Agent 4: Caching optimization
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━Step 7: Create Finalized Implementation Plan
步骤7：制定最终实现计划
Before implementing, create a detailed execution plan from the synthesized solution:
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
📋 IMPLEMENTATION PLAN
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━在执行实现前，基于合成方案创建详细的执行计划：
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
📋 IMPLEMENTATION PLAN
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━Files to Create
Files to Create
| # | File Path | Purpose | Source |
|---|---|---|---|
| 1 | path/to/NewService.ts | Main service class | Agent 3 base |
| 2 | path/to/types.ts | Type definitions | Agent 2 |
| 3 | path/to/utils.ts | Helper functions | Agent 5 |
| # | File Path | Purpose | Source |
|---|---|---|---|
| 1 | path/to/NewService.ts | Main service class | Agent 3 base |
| 2 | path/to/types.ts | Type definitions | Agent 2 |
| 3 | path/to/utils.ts | Helper functions | Agent 5 |
Files to Modify
Files to Modify
| # | File Path | Changes | Source |
|---|---|---|---|
| 1 | path/to/index.ts | Add export | Agent 3 |
| 2 | path/to/config.ts | Add config entry | Agent 4 |
| 3 | path/to/app.ts | Register service | Agent 3 |
| # | File Path | Changes | Source |
|---|---|---|---|
| 1 | path/to/index.ts | Add export | Agent 3 |
| 2 | path/to/config.ts | Add config entry | Agent 4 |
| 3 | path/to/app.ts | Register service | Agent 3 |
Implementation Order
Implementation Order
-
Create types.ts (no dependencies)
- Define interfaces and types
- From: Agent 2
-
Create utils.ts (depends on types)
- Add helper functions
- From: Agent 5
-
Create NewService.ts (depends on types, utils)
- Main implementation
- From: Agent 3 + Agent 2 error handling
-
Modify config.ts (no dependencies)
- Add configuration
- From: Agent 4
-
Modify index.ts (depends on NewService)
- Export new service
- From: Agent 3
-
Modify app.ts (depends on all above)
- Register and initialize
- From: Agent 3
-
Create types.ts (no dependencies)
- Define interfaces and types
- From: Agent 2
-
Create utils.ts (depends on types)
- Add helper functions
- From: Agent 5
-
Create NewService.ts (depends on types, utils)
- Main implementation
- From: Agent 3 + Agent 2 error handling
-
Modify config.ts (no dependencies)
- Add configuration
- From: Agent 4
-
Modify index.ts (depends on NewService)
- Export new service
- From: Agent 3
-
Modify app.ts (depends on all above)
- Register and initialize
- From: Agent 3
Edge Cases to Handle
Edge Cases to Handle
| Edge Case | How Handled | Source |
|---|---|---|
| Empty input | Return early with default | Agent 5 |
| Null values | Null coalescing + validation | Agent 2 |
| Concurrent access | Mutex lock | Agent 5 |
| Network timeout | Retry with backoff | Agent 4 |
| Edge Case | How Handled | Source |
|---|---|---|
| Empty input | Return early with default | Agent 5 |
| Null values | Null coalescing + validation | Agent 2 |
| Concurrent access | Mutex lock | Agent 5 |
| Network timeout | Retry with backoff | Agent 4 |
Error Handling Strategy
Error Handling Strategy
- Pattern: [from Agent 2]
- Logging: [approach]
- Recovery: [approach]
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
This plan ensures:
- Correct dependency order
- All edge cases addressed
- Clear traceability to source agents- Pattern: [from Agent 2]
- Logging: [approach]
- Recovery: [approach]
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
该计划确保：
- 依赖顺序正确
- 所有边缘场景都被覆盖
- 可清晰追溯元素来源AgentStep 8: Execute Implementation Plan
步骤8：执行实现计划
Follow the plan step-by-step. For each step:
- Create/modify the file as specified
- Verify it matches the synthesized approach
- Move to next step
逐步执行计划。每一步：
- 按要求创建/修改文件
- 验证是否符合合成方案
- 进入下一步
Step 9: Report Results
步骤9：汇报结果
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
FEATURE COUNCIL RESULTS
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
FEATURE COUNCIL RESULTS
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━📊 Implementation Comparison
📊 Implementation Comparison
| Agent | Architecture | Edge Cases | Error Handling | Codebase Fit |
|---|---|---|---|---|
| 1 | [approach] | [count] | [quality] | [%] |
| 2 | [approach] | [count] | [quality] | [%] |
| ... | ... | ... | ... | ... |
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
| Agent | Architecture | Edge Cases | Error Handling | Codebase Fit |
|---|---|---|---|---|
| 1 | [approach] | [count] | [quality] | [%] |
| 2 | [approach] | [count] | [quality] | [%] |
| ... | ... | ... | ... | ... |
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
🔍 What Each Agent Contributed
🔍 What Each Agent Contributed
Agent 1
Agent 1
- Approach: [brief description]
- Unique strength: [what this agent did best]
- Used in final: [what was incorporated]
- Approach: [brief description]
- Unique strength: [what this agent did best]
- Used in final: [what was incorporated]
Agent 2
Agent 2
- Approach: [brief description]
- Unique strength: [what this agent did best]
- Used in final: [what was incorporated]
... (for each agent)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
- Approach: [brief description]
- Unique strength: [what this agent did best]
- Used in final: [what was incorporated]
... (for each agent)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
📋 Implementation Plan Executed
📋 Implementation Plan Executed
| Step | File | Action | Status |
|---|---|---|---|
| 1 | path/to/types.ts | Created | ✅ |
| 2 | path/to/utils.ts | Created | ✅ |
| 3 | path/to/Service.ts | Created | ✅ |
| 4 | path/to/config.ts | Modified | ✅ |
| 5 | path/to/index.ts | Modified | ✅ |
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
| Step | File | Action | Status |
|---|---|---|---|
| 1 | path/to/types.ts | Created | ✅ |
| 2 | path/to/utils.ts | Created | ✅ |
| 3 | path/to/Service.ts | Created | ✅ |
| 4 | path/to/config.ts | Modified | ✅ |
| 5 | path/to/index.ts | Modified | ✅ |
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
🧬 Synthesis Breakdown
🧬 Synthesis Breakdown
| Element | Source Agent | Reason |
|---|---|---|
| Base architecture | Agent 3 | Best codebase pattern match (95%) |
| Error handling | Agent 2 | Most comprehensive try/catch + logging |
| Edge case: empty input | Agent 5 | Only agent that handled this |
| Edge case: concurrent | Agent 5 | Race condition prevention |
| Type definitions | Agent 2 | Strictest typing |
| Caching layer | Agent 4 | Performance optimization |
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
| Element | Source Agent | Reason |
|---|---|---|
| Base architecture | Agent 3 | Best codebase pattern match (95%) |
| Error handling | Agent 2 | Most comprehensive try/catch + logging |
| Edge case: empty input | Agent 5 | Only agent that handled this |
| Edge case: concurrent | Agent 5 | Race condition prevention |
| Type definitions | Agent 2 | Strictest typing |
| Caching layer | Agent 4 | Performance optimization |
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
📈 Final Solution Quality
📈 Final Solution Quality
- Edge Cases Covered: [total unique from all agents]
- Error Handling: [description]
- Codebase Fit: [% and explanation]
- Type Safety: [description]
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
- Edge Cases Covered: [total unique from all agents]
- Error Handling: [description]
- Codebase Fit: [% and explanation]
- Type Safety: [description]
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
✅ Implemented Solution
✅ Implemented Solution
[The synthesized implementation]
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
[The synthesized implementation]
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
📁 Files Created/Modified
📁 Files Created/Modified
[List of all files with brief descriptions]
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
---[List of all files with brief descriptions]
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
---Configuration
配置选项
| Mode | Agents | Use Case |
|---|---|---|
| 3 | Simple features, faster |
| 5 | Good balance |
| 7 | Complex features |
| 10 | Maximum coverage |
If user just says , ask them to choose.
feature council| 模式 | Agent数量 | 适用场景 |
|---|---|---|
| 3 | 简单功能，速度更快 |
| 5 | 平衡多样性与速度 |
| 7 | 复杂功能 |
| 10 | 最大覆盖范围 |
如果用户仅输入，请让用户选择具体数量。
feature councilDifference from Code Council
与Code Council的区别
| Aspect | Code Council | Feature Council |
|---|---|---|
| Purpose | Bug fixes, algorithms | Feature implementation |
| Selection | Majority voting | Synthesis/merge |
| Output | Single winning solution | Best-of-all combined |
| Metric | Correctness consensus | Comprehensiveness |
| 维度 | Code Council | Feature Council |
|---|---|---|
| 用途 | Bug修复、算法实现 | 功能实现 |
| 选择机制 | 多数投票 | 合成/整合 |
| 输出 | 单一胜出方案 | 整合所有优势的方案 |
| 评估指标 | 正确性共识 | 全面性 |
Agents
Agent说明
10 feature solver agents in directory:
agents/- through
feature-solver-1feature-solver-10
All agents:
- Same instructions (focused on feature implementation)
- Same temperature (0.7)
- Same tools (Read, Grep, Glob, LS)
- Use ultrathink (extended thinking)
- Emphasize codebase pattern matching and edge case coverage
agents/- 至
feature-solver-1feature-solver-10
所有Agent：
- 遵循相同指令（聚焦功能实现）
- 相同温度参数（0.7）
- 相同工具集（Read、Grep、Glob、LS）
- 使用ultrathink（扩展思考能力）
- 强调匹配代码库模式与覆盖边缘场景
Why Synthesis > Voting for Features
为何功能实现更适合合成而非投票
With bugs, there's ONE correct answer. With features:
- Multiple valid architectures exist
- One agent might catch edge cases others miss
- Error handling approaches can be combined
- Type safety can be merged
Synthesis captures the union of good ideas rather than picking one.
Bug修复通常只有一个正确答案，但功能实现：
- 存在多种有效架构
- 不同Agent可能发现其他Agent遗漏的边缘场景
- 错误处理方案可整合
- 类型安全逻辑可合并
合成机制能捕捉所有优秀想法的集合，而非仅选择某一个方案。
When to Use
适用场景
✅ Use feature-council for:
- Complex features with many edge cases
- Features where you're unsure of best approach
- High-stakes production code
- When you want comprehensive coverage
❌ Don't use for:
- Simple CRUD operations
- Bug fixes (use code-council instead)
- When speed matters more than coverage
✅ 推荐使用Feature Council的场景：
- 存在大量边缘场景的复杂功能
- 不确定最优实现方案的功能
- 高风险生产代码
- 需要全面覆盖的功能
❌ 不推荐使用的场景：
- 简单CRUD操作
- Bug修复（请使用Code Council）
- 优先考虑速度而非覆盖范围的场景