Agent-Skills.md

Agent Skills: Feature Planning

Break down features into implementable tasks and choose architecture approach. Use when starting a new feature or receiving requirements that need technical decomposition.

UncategorizedID: dagba/ios-mcp/feature-planning

Repository

dagba/ios-mcp
dagbaLicense: MIT
32

Install this agent skill to your local

pnpm dlx add-skill https://github.com/dagba/ios-mcp/tree/HEAD/skills/feature-planning

Skill Files

Browse the full folder contents for feature-planning.

Download Skill

Loading file tree…

skills/feature-planning/SKILL.md

Skill Metadata

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:

  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