| name | feature-planning |
| description | Break down features into implementable tasks and choose architecture approach. Use when starting a new feature or receiving requirements that need technical decomposition. |
Feature Planning
Overview
Systematic approach to decompose features into actionable tasks. For senior engineers who know how to code but need a structured thinking framework.
Quick Workflow
1. Requirement Analysis
- Clarify user goal and acceptance criteria
- Identify screens, data flows, integration points
- Ask: API ready? Design assets available? Platform requirements?
2. Choose Architecture
Use architecture-patterns skill to decide:
- Simple (1-2 screens, local state) → MV
- Medium (3-5 screens, business logic) → MVVM
- Complex (state machines, side effects) → TCA
- Enterprise (multi-team) → Clean Architecture
3. Task Breakdown Structure
Phase 1: Foundation
- Models/entities
- API client stubs
- Navigation structure
Phase 2: Core Logic
- ViewModels/Reducers
- Business rules
- State management
Phase 3: UI
- Layouts and components
- Styling and animations
- Loading/error states
Phase 4: Integration
- Wire up ViewModels to Views
- Connect to backend
- Handle edge cases
Phase 5: Quality
- Unit tests (ViewModels, business logic)
- UI tests (critical flows)
- Accessibility audit
4. Risk Assessment
| Risk | Mitigation |
|---|
| Unknown APIs | Define contract early, use mocks |
| New technology | POC spike first, allocate learning time |
| Performance concerns | Profile early, plan caching/pagination |
| Tight deadline | Negotiate scope, identify MVP |
5. Estimation
Rule of Thumb: Sum task estimates + 30-50% buffer
Break tasks into <1 day chunks. If a task feels >1 day, decompose further.
Implementation Plan Template
# Feature: [Name]
## Overview
[1-2 sentences: what and why]
## Architecture
Pattern: MVVM
State: @Observable
Navigation: NavigationStack
## Tasks
### Phase 1: Foundation (Day 1)
- [ ] Define models
- [ ] Create API client protocol
- [ ] Setup navigation routes
### Phase 2: Logic (Day 2-3)
- [ ] Implement ViewModels
- [ ] Add validation
- [ ] Handle errors
### Phase 3: UI (Day 4)
- [ ] Build main screen
- [ ] Add animations
- [ ] Loading states
### Phase 4: Testing (Day 5)
- [ ] Unit tests
- [ ] UI tests
## Dependencies
- Backend API: [Status]
- Design: [Link]
- Third-party: [None/List]
## Risks
[Table from Risk Assessment]
## Acceptance Criteria
- [ ] User can [action]
- [ ] Error handling complete
- [ ] Unit test coverage >80%
- [ ] Accessibility labels
Integration with Other Skills
Typical flow:
- feature-planning (this skill) - Decompose and plan
- architecture-patterns - Implement chosen pattern
- swiftui-*-patterns - Build UI
- swift-concurrency-expert - Fix concurrency issues
- Verify and ship
Key Principles
- Break tasks <1 day - Forces clarity, enables parallelization
- Identify MVP early - Know what's must-have vs. nice-to-have
- Plan for testing - Not an afterthought
- Document decisions - Record why you chose an approach
- 30-50% buffer - Accounts for unknowns and review cycles
Word count: ~400 (was 2,099)
For: Senior/mid engineers who need structure, not hand-holding
Focus: Decision-making and decomposition, not tutorials
