DELIBERATION MODE
Analyze requirements and decompose tasks for: $ARGUMENTS
System Prompt
⚠️ EXECUTION DIRECTIVE: When the user invokes this command, you MUST:
- IMMEDIATELY execute - no questions, no explanations first
- ALWAYS show full output from script/tool execution
- ALWAYS provide summary after execution completes
DO NOT:
- Say "I don't need to take action" - you ALWAYS execute when invoked
- Ask for confirmation unless
requires_confirmation: truein frontmatter - Skip execution even if it seems redundant - run it anyway
The user invoking the command IS the confirmation.
Usage
# Plan a feature implementation
/deliberation "user authentication system"
# Analyze requirements for a task
/deliberation "migrate from REST to GraphQL"
# Decompose complex work
/deliberation "implement real-time collaboration features"
# Clarify ambiguous requirements
/deliberation "optimize database performance"
Mode Rules
❌ STRICTLY FORBIDDEN
- NO code execution - Analysis only
- NO tool calls (except Read for context gathering)
- NO implementation - Planning phase only
- NO premature solutions - Explore problem space first
✅ REQUIRED ACTIVITIES
- Pure analysis - Understand requirements deeply
- Task decomposition - Break into logical phases
- Gap identification - Find missing information
- Dependency mapping - Understand relationships
- Question formulation - Clarify ambiguities
Deliberation Framework
Phase 1: Requirement Analysis
## Requirements Understanding
### Explicit Requirements
1. [Requirement as stated]
2. [Requirement as stated]
### Implied Requirements
1. [Inferred from context]
2. [Inferred from context]
### Ambiguities / Questions
1. [Unclear aspect] - Need clarification on X
2. [Missing detail] - Should we assume Y or Z?
### Constraints
- Technical: [Framework, language, platform]
- Business: [Timeline, resources]
- Dependencies: [External systems]
Phase 2: Task Decomposition
## Task Breakdown
### Phase 1: [Phase Name]
**Duration**: [Estimated time]
**Complexity**: [Low/Medium/High]
**Dependencies**: [What must be done first]
Tasks:
1. [Specific task] - [Why needed]
2. [Specific task] - [Why needed]
### Phase 2: [Phase Name]
[... repeat structure ...]
## Dependency Graph
Phase 1 (Foundation) ├─> Phase 2 (Core) │ └─> Phase 4 (Integration) └─> Phase 3 (Auxiliary) └─> Phase 4 (Integration)
Phase 3: Complexity Assessment
## Complexity Analysis
### Token Budget Estimate
- Phase 1: 15K tokens (research + design)
- Phase 2: 25K tokens (implementation)
- Phase 3: 10K tokens (testing)
- **Total**: 50K tokens
### Risk Zones
- **High Risk**: [Aspect with high complexity]
- **Medium Risk**: [Aspect with moderate complexity]
- **Low Risk**: [Well-understood aspects]
### Recommended Strategy
Based on complexity: [Use /complexity-gauge, /recursive-workflow, orchestrator, etc.]
Phase 4: Alternative Approaches
## Approaches Considered
### Approach 1: [Name]
**Pros**: [Benefits]
**Cons**: [Drawbacks]
**Complexity**: [Assessment]
**Recommendation**: [Yes/No/Maybe]
### Approach 2: [Name]
[... repeat structure ...]
### Recommended Approach
[Chosen approach with rationale]
Output Structure
# Deliberation: [Feature/Task Name]
## Executive Summary
[2-3 sentences: What we're building, why, high-level approach]
## Requirement Analysis
[See Phase 1 above]
## Task Decomposition
[See Phase 2 above]
## Complexity Assessment
[See Phase 3 above]
## Alternative Approaches
[See Phase 4 above]
## Questions for User
1. [Clarifying question 1]
2. [Clarifying question 2]
## Next Steps
**If approved, transition to**: RESEARCH mode (verify assumptions) or ACTION mode (implementation)
**Ready to proceed?**
Integration
- Auto-load:
multi-agent-workflowskill (token estimation) - Auto-load:
framework-patternsskill (architecture options) - Use:
/complexity-gaugefor token budget analysis
Transition Protocol
After deliberation complete:
**Deliberation complete. Ready to transition:**
Option 1: RESEARCH mode
- Verify technical assumptions
- Check if packages/APIs exist
- Validate approach feasibility
- Estimated: 5-10 tool calls
Option 2: ACTION mode (if confident)
- Skip verification
- Proceed directly to implementation
- Use deliberation plan as blueprint
Which mode should we use next?
Best Practices
✅ DO:
- Ask clarifying questions
- Consider multiple approaches
- Identify dependencies explicitly
- Estimate complexity honestly
- Note assumptions clearly
❌ DON'T:
- Jump to implementation
- Make unjustified assumptions
- Skip dependency analysis
- Ignore edge cases
- Provide only one approach
Action Policy
<default_behavior> This command analyzes and recommends without making changes. Provides:
- Detailed analysis of current state
- Specific recommendations with justification
- Prioritized action items
- Risk assessment
User decides which recommendations to implement. </default_behavior>
Success Output
When deliberation completes:
✅ COMMAND COMPLETE: /deliberation
Topic: <feature/task>
Requirements: N explicit, N implied
Phases: N identified
Complexity: <Low|Medium|High>
Approaches: N considered
Questions: N for user
Completion Checklist
Before marking complete:
- Requirements analyzed
- Tasks decomposed
- Complexity assessed
- Approaches considered
- Questions formulated
Failure Indicators
This command has FAILED if:
- ❌ No requirements identified
- ❌ No task breakdown
- ❌ No complexity estimate
- ❌ No next steps
When NOT to Use
Do NOT use when:
- Simple task (no planning needed)
- Already have clear plan
- Implementation phase started
Anti-Patterns (Avoid)
| Anti-Pattern | Problem | Solution |
|---|---|---|
| Jump to implementation | Missing requirements | Complete deliberation first |
| Single approach | Missed alternatives | Consider multiple options |
| Skip questions | Wrong assumptions | Ask clarifying questions |
Principles
This command embodies:
- #5 No Assumptions - Ask clarifying questions
- #9 Based on Facts - Analyze requirements
- #6 Clear, Understandable - Structured output
Full Standard: CODITECT-STANDARD-AUTOMATION.md