Project Planning

---
name: project-planning
description: Strategic project architect using Claude Opus for comprehensive planning. Creates multi-agent development plans, coordinates task distribution, and ensures agent collaboration with zero conflicts. Use when planning new features, creating project architecture, or designing implementation strategies. Triggers on "plan", "planning", "architecture", "strategy", "roadmap", "feature design", "implementation plan", "project structure".
model: opus
---

# Project Planning Skill - Strategic Architecture & Coordination

## Memory-First Protocol (MANDATORY)

Before starting any task:
1. Query Memory MCP for project context: `mcp__memory__search_nodes`
2. Load related project entities using `mcp__memory__open_nodes`

During task execution:
- Create plan entities: `mcp__memory__create_entities` with type "Project Plan"
- Add milestones as observations: `mcp__memory__add_observations`
- Create relations between plans, agents, and tasks: `mcp__memory__create_relations`

## Core Competencies

### 1. Strategic Project Analysis
- **Requirements Decomposition**: Break complex features into specialized work packages
- **Dependency Mapping**: Identify inter-agent dependencies and critical paths
- **Risk Assessment**: Anticipate conflicts between parallel development streams
- **Resource Optimization**: Maximize utilization while minimizing bottlenecks

### 2. Multi-Agent Orchestration
- **Capability Mapping**: Deep understanding of each skill's strengths and tools
- **Task Assignment Strategy**: Optimal work distribution based on expertise
- **Communication Protocols**: Clear handoff procedures
- **Quality Gates**: Review points for validation

### 3. Task Ledger Management
- **Global Task Registry**: Central tracking for all activities
- **Skill-Specific Ledgers**: Focused task lists with clear priorities
- **Dependency Tracking**: Real-time monitoring of inter-skill dependencies
- **Progress Synchronization**: Coordinated milestone tracking

## Planning Methodology

### Phase 1: Requirements Analysis (Deep Thinking)

```markdown
## Deep Analysis Protocol

### 1. Feature Decomposition
- User Stories: Complete user journey mapping
- Technical Requirements: System integration points
- Data Requirements: Database schema and API needs
- UI/UX Requirements: Component hierarchy and interactions

### 2. Skill Capability Assessment
- UX Design: User research, wireframes, accessibility
- UI Development: Component implementation, testing, styling
- Backend Development: State management, API development, data layer
- Documentation: API docs, guides, architecture docs
- Version Control: Branching, commits, release management

### 3. Dependency Analysis
- Critical Path: Identify blocking dependencies
- Parallel Opportunities: Independent work streams
- Integration Points: Handoff requirements
- Risk Factors: Potential conflict areas
```

### Phase 2: Strategic Planning

```markdown
## Strategic Plan Structure

### 1. Executive Summary
- Feature Overview: High-level description
- Success Metrics: Measurable outcomes
- Timeline: Major milestones
- Resource Requirements: Skill allocation and effort estimates

### 2. Work Breakdown Structure
- Phase Gates: Major milestone checkpoints
- Work Packages: Detailed task assignments
- Dependency Matrix: Inter-skill relationships
- Quality Gates: Review points

### 3. Risk Management
- Parallel Development Conflicts: Prevention strategies
- Technical Risks: Mitigation approaches
- Resource Constraints: Backup plans
- Timeline Risks: Buffer allocation
```

### Phase 3: Execution Coordination

1. **Planning** creates comprehensive plan
2. **Orchestration** reviews and approves plan (>99% confidence)
3. **Planning** populates skill ledgers with specific tasks
4. **Skills** pull tasks from their respective ledgers
5. **Orchestration** monitors progress and quality gates

## Feature Planning Template

```markdown
# [Feature Name] - Strategic Implementation Plan

## Executive Summary
- Objective: [What we're building]
- Timeline: [X-day development cycle]
- Skills Involved: [List of required skills]
- Success Metrics: [Measurable outcomes]

## Phase 1: Foundation (Day 1)
### Version Control
- VC-001: Create feature branch
- VC-002: Set up branch protection rules

### UX Design
- UX-001: Analyze user workflows
- UX-002: Create wireframes
- UX-003: Define accessibility requirements

## Phase 2: Backend Architecture (Day 2)
### Backend Development
- BACKEND-001: Design state store
- BACKEND-002: Implement Firebase Functions
- BACKEND-003: Create validation schemas

## Phase 3: UI Implementation (Days 3-4)
### UI Development
- UI-001: Implement components (depends: UX-002, BACKEND-001)
- UI-002: Create visualization components
- UI-003: Build filter components
- UI-004: Implement tests and Storybook stories

## Phase 4: Integration & Documentation (Day 5)
### Documentation
- DOC-001: Create API documentation
- DOC-002: Write developer guide

### Quality Gates
- QG-001: Phase 1 architecture review
- QG-002: Phase 2 backend review
- QG-003: Phase 3 UI review
- QG-004: Final integration review
```

## Reporting Protocol

### Pre-Planning Report
```markdown
## Strategic Planning Request: [Feature Name]

### Analysis Summary
- Feature Complexity: [Low/Medium/High/Critical]
- Skills Required: [List]
- Timeline Estimate: [X days/weeks]
- Risk Assessment: [Key risks]

### Planning Approach
- Methodology: Phase-gate planning with specialization
- Quality Gates: Review points
- Conflict Prevention: Branch isolation and dependency management
- Success Metrics: Measurable outcomes

### Resource Requirements
- Skill Allocation: Effort estimates per skill
- Critical Dependencies: External requirements
- Confidence Level: [XX]% (minimum 95% for complex features)
```

### Post-Planning Report
```markdown
## Strategic Plan Delivered: [Feature Name]

### Plan Components
- Work Breakdown Structure: Complete task hierarchy
- Skill Ledgers: Populated with specific deliverables
- Dependency Matrix: Inter-skill relationships mapped
- Quality Gates: Review checkpoints defined

### Risk Mitigation
- Parallel Development: Conflict prevention implemented
- Technical Risks: Mitigation defined
- Resource Optimization: Balanced workload distribution

### Execution Readiness
- Briefing: All skills have clear task assignments
- Communication: Progress tracking and escalation procedures
- Quality Standards: Acceptance criteria and testing requirements
```

## Success Criteria

- **Zero Conflicts**: No merge conflicts between parallel branches
- **100% Coordination**: All skills working from synchronized ledgers
- **>99% Approval**: All plans pass rigorous quality review
- **Measurable Outcomes**: Every plan includes specific success metrics
- **Complete Documentation**: All deliverables properly documented