---

name: project-planning description: Transform specifications into structured implementation plans with architecture design and task breakdown

Triggers: architecture, project, planning, into, specifications model_preference: claude-sonnet-4

Table of Contents

• When to Use
• Integration
• Planning Phases
• Phase 1: Architecture Design
• Phase 2: Task Breakdown
• Phase 3: Dependency Analysis
• Phase 4: Sprint Planning
• Architecture Design Patterns
• Component Identification
• Component Template
• Component: [Name]
• Task Breakdown Template
• TASK-[XXX]: [Task Name]
• Task Estimation Guidelines
• Dependency Graph
• Sprint Structure
• Sprint [N]: [Focus Area]
• Planned Tasks ([X] story points)
• Deliverable
• Risks
• Dependencies
• Risk Assessment
• Output Format
• Architecture
• System Overview
• Component Diagram
• Components
• Data Flow
• Task Breakdown
• Phase 1: [Name] (Sprint [N]) - TASK-001 through TASK-010
• Phase 2: [Name] (Sprint [M]) - TASK-011 through TASK-020
• Dependency Graph
• Sprint Schedule
• Risk Assessment
• Success Metrics
• Timeline
• Next Steps
• Quality Checks
• Related Skills
• Related Commands
• Examples

Project Planning Skill

Transform specification into implementation plan with architecture design and dependency-ordered tasks.

When to Use

• After specification phase completes
• Need to design system architecture
• Need task breakdown for implementation
• Planning sprints and resource allocation

Integration

With superpowers:

• Uses Skill(superpowers:writing-plans) for structured planning
• Applies checkpoint-based execution patterns
• Uses dependency analysis framework

Without superpowers:

• Standalone planning methodology
• Task breakdown templates
• Dependency tracking patterns

Planning Phases

Phase 1: Architecture Design

Activities:

1. Identify system components
2. Define component responsibilities
3. Design interfaces between components
4. Map data flows
5. Select technologies

Output: Architecture documentation with diagrams

Phase 2: Task Breakdown

Activities:

1. Decompose FRs into implementation tasks
2. Add testing tasks for each FR
3. Add infrastructure tasks
4. Add documentation tasks
5. Estimate each task

Output: Task list with estimates

Phase 3: Dependency Analysis

Activities:

1. Identify task dependencies
2. Create dependency graph
3. Identify critical path
4. Detect circular dependencies
5. Optimize for parallelization

Output: Dependency-ordered task execution plan

Phase 4: Sprint Planning

Activities:

1. Group tasks into sprints
2. Balance sprint workload
3. Identify milestones
4. Plan releases
5. Allocate resources

Output: Sprint schedule with milestones

Architecture Design Patterns

Component Identification

Questions:

• What are the major functional areas?
• What concerns should be separated?
• What components can be developed independently?
• What components can be reused?

Common Patterns:

• Frontend/Backend: Separate UI from business logic
• API Layer: Separate interface from implementation
• Data Layer: Separate data access from business logic
• Integration Layer: Isolate external dependencies

Component Template

### Component: [Name]

**Responsibility**: [What this component does]

**Technology**: [Stack and tools]

**Interfaces**:
- [Interface 1]: [Description]
- [Interface 2]: [Description]

**Dependencies**:
- [Component 1]: [What's needed]
- [Component 2]: [What's needed]

**Data**:
- [Data structure 1]
- [Data structure 2]

**Configuration**:
- [Config param 1]
- [Config param 2]

Verification: Run the command with --help flag to verify availability.

Task Breakdown Template

### TASK-[XXX]: [Task Name]

**Description**: [What needs to be done]

**Type**: Implementation | Testing | Documentation | Infrastructure | Deployment
**Priority**: P0 (Critical) | P1 (High) | P2 (Medium) | P3 (Low)
**Estimate**: [Story points or hours]
**Dependencies**: TASK-XXX, TASK-YYY
**Sprint**: Sprint N
**Assignee**: [Name or TBD]

**Linked Requirements**: FR-XXX, NFR-YYY

**Acceptance Criteria**:
- [ ] [Criterion 1]
- [ ] [Criterion 2]
- [ ] Tests passing
- [ ] Documentation updated

**Technical Notes**:
- [Implementation detail 1]
- [Implementation detail 2]

**Testing Requirements**:
- Unit tests: [What to test]
- Integration tests: [What to test]
- E2E tests: [What to test]

**Definition of Done**:
- [ ] Code complete
- [ ] Tests passing
- [ ] Code reviewed
- [ ] Documentation updated
- [ ] Deployed to staging

Verification: Run pytest -v to verify tests pass.

Task Estimation Guidelines

Story Points (Fibonacci):

• 1 point: < 2 hours, trivial, well-understood
• 2 points: 2-4 hours, straightforward
• 3 points: 4-8 hours, some complexity
• 5 points: 1-2 days, moderate complexity
• 8 points: 2-3 days, significant complexity
• 13 points: 3-5 days, high complexity (consider breaking down)
• 21 points: > 5 days, very complex (MUST break down)

Factors to consider:

• Technical complexity
• Uncertainty/unknowns
• Dependencies on other work
• Testing requirements
• Documentation needs

Dependency Graph

Notation:

**Verification:** Run `pytest -v` to verify tests pass.
TASK-001 (Foundation)
    ├─▶ TASK-002 (Database schema)
    │       ├─▶ TASK-003 (Models)
    │       └─▶ TASK-011 (Data import)
    └─▶ TASK-004 (Authentication)
            └─▶ TASK-005 (Auth middleware)
                    └─▶ TASK-010 (Protected endpoints)

Verification: Run the command with --help flag to verify availability.

Validation:

• No circular dependencies (A depends on B, B depends on A)
• Critical path identified
• Parallel work opportunities identified
• Blocking tasks highlighted

Sprint Structure

Sprint Template:

## Sprint [N]: [Focus Area]

**Dates**: [Start] - [End]
**Goal**: [Sprint objective]
**Capacity**: [Team capacity in story points]

### Planned Tasks ([X] story points)
- TASK-XXX ([N] points)
- TASK-YYY ([M] points)
- ...

### Deliverable
[What will be demonstrable at sprint end]

### Risks
- [Risk 1 with mitigation]
- [Risk 2 with mitigation]

### Dependencies
- [External dependency 1]
- [External dependency 2]

Verification: Run the command with --help flag to verify availability.

Risk Assessment

Risk Template:

| Risk | Impact | Probability | Mitigation |
|------|--------|-------------|------------|
| [Risk description] | High/Med/Low | High/Med/Low | [How to address] |

Verification: Run the command with --help flag to verify availability.

Common Risks:

• Technology unknowns
• Third-party API dependencies
• Resource availability
• Scope creep
• Performance issues
• Security vulnerabilities

Output Format

Save to docs/implementation-plan.md:

# [Project Name] - Implementation Plan v[version]

**Author**: [Name]
**Date**: [YYYY-MM-DD]
**Sprint Length**: [Duration]
**Team Size**: [Number]
**Target Completion**: [Date]

## Architecture

### System Overview
[High-level architecture description]

### Component Diagram
[ASCII or markdown diagram]

### Components
[Component details using template above]

### Data Flow
[How data moves through system]

## Task Breakdown

### Phase 1: [Name] (Sprint [N]) - TASK-001 through TASK-010

[Tasks using template above]

### Phase 2: [Name] (Sprint [M]) - TASK-011 through TASK-020

[Tasks using template above]

## Dependency Graph

[Dependency visualization]

## Sprint Schedule

[Sprint details using template above]

## Risk Assessment

[Risk table]

## Success Metrics

- [ ] [Metric 1]
- [ ] [Metric 2]

## Timeline

| Sprint | Dates | Focus | Deliverable |
|--------|-------|-------|-------------|
| 1 | Jan 3-16 | Foundation | Dev environment |
| 2 | Jan 17-30 | Core | Feature X working |

## Next Steps

1. Review plan with team
2. Initialize project with `/attune:init`
3. Start execution with `/attune:execute`

Verification: Run the command with --help flag to verify availability.

Quality Checks

Before completing plan:

• ✅ All architecture components documented
• ✅ All FRs mapped to tasks
• ✅ All tasks have acceptance criteria
• ✅ Dependencies are acyclic
• ✅ Effort estimates provided
• ✅ Critical path identified
• ✅ Risks assessed with mitigations
• ✅ Sprints balanced by capacity

Related Skills

• Skill(superpowers:writing-plans) - Planning methodology (if available)
• Skill(spec-kit:task-planning) - Task breakdown (if available)
• Skill(attune:project-specification) - Previous phase
• Skill(attune:project-execution) - Next phase

Related Commands

• /attune:plan - Invoke this skill
• /attune:execute - Next step in workflow

Examples

See /attune:plan command documentation for complete examples.

Troubleshooting

Common Issues

Command not found Ensure all dependencies are installed and in PATH

Permission errors Check file permissions and run with appropriate privileges

Unexpected behavior Enable verbose logging with --verbose flag