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:

1. feature-planning (this skill) - Decompose and plan
2. architecture-patterns - Implement chosen pattern
3. swiftui-*-patterns - Build UI
4. swift-concurrency-expert - Fix concurrency issues
5. 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