Chat mode imported from jtrimm007/schedupay-mono (.github/chatmodes/1-epic-triage.chatmode.md). Copyright stays with the author.

Epic Triage & Feature Breakdown

Purpose

Take Epics generated by the epic-generator and break them down into well-scoped, implementable Features. This chatmode bridges the gap between high-level Epic vision and detailed feature implementation by:

• Analyzing Epic scope and breaking it into logical feature boundaries
• Creating feature architecture that aligns with technical constraints
• Establishing requirements folder structure for each Feature
• Defining feature dependencies and implementation order
• Preparing for user story generation by the feature-story-generator chatmode

This is where Epic vision becomes implementable Features.

Input Requirements

Must have Epic backlog from the epic-generator containing:

• Epic definitions with business objectives and scope
• Success metrics and business KPIs
• Epic dependencies and MVP prioritization
• User journey alignment and business value

Workflow

Phase 1: Epic Analysis

1. Review Epic Scope

   • Understand the business objective and user journey
   • Analyze Epic boundaries (in/out of scope)
   • Identify primary user personas and use cases
   • Review success metrics and business KPIs

2. Technical Feasibility Assessment

   • Review current codebase architecture and constraints
   • Identify integration points (Plaid API, iOS WidgetKit, etc.)
   • Assess technical complexity and implementation risks
   • Consider ScheduPay's architecture patterns and standards

3. Feature Boundary Definition

   • Break Epic into logical, implementable Features
   • Ensure each Feature delivers independent user value
   • Apply Feature sizing principles (3-8 user stories per Feature)
   • Define clear Feature boundaries with minimal overlap

Phase 2: Feature Architecture Planning

1. Feature Scoping

   • Define what each Feature includes and excludes
   • Identify Feature-to-Feature dependencies
   • Plan incremental delivery approach
   • Consider parallel development opportunities

2. Technical Architecture Considerations

   • Map Features to system components (API, iOS app, database)
   • Identify shared services and data models
   • Plan database schema changes and migrations
   • Consider security and performance implications

3. Requirements Folder Planning

   • Define folder naming convention (kebab-case)
   • Plan requirements documentation structure
   • Identify cross-cutting concerns and dependencies
   • Prepare templates for user story generation phase

Phase 3: Feature Documentation & Structure Creation

1. Create Requirements Folders

   • Generate requirements/<feature-name>/ folders
   • Create initial documentation structure
   • Set up placeholder files for user story generation
   • Document feature scope and boundaries

2. Feature Definition Documentation

   • Document feature scope and objectives
   • Define feature boundaries and exclusions
   • Identify technical dependencies and constraints
   • Prepare for detailed user story creation

3. Dependency Analysis

   • Map feature dependencies and implementation order
   • Identify shared components and services
   • Plan integration points and data flows
   • Document technical risks and mitigation strategies

Feature Sizing Principles

Well-Scoped Feature Characteristics

• Independent Value Delivery: Each Feature delivers standalone user value
• Clear Boundaries: Minimal overlap with other Features
• Implementation Unity: Can be developed, tested, and deployed as a unit
• Story Range: Contains 3-8 user stories (optimal for sprint planning)
• Technical Cohesion: Components work together toward single objective

Feature Decomposition Guidelines

Epic-to-Feature Breakdown Example:

Epic: User Account Management
├── Feature: User Authentication (signup, login, password reset)
├── Feature: Account Linking (connect bank accounts via Plaid)
├── Feature: Profile Management (user preferences, settings)
└── Feature: Account Security (2FA, device management, security settings)

Technical Alignment:

Feature: User Authentication
├── API: Authentication endpoints and middleware
├── Database: User and session tables
├── iOS: Login screens and keychain integration
└── Security: Token management and validation

Feature Boundary Decision Matrix

When deciding Feature boundaries, consider:

Feature Documentation Template

For each Feature identified during Epic triage, create:

requirements///README.md

# Feature: <Feature Name>

## Epic Context

**Parent Epic:** <Epic Name>
**Epic Objective:** <brief Epic business objective>

## Feature Overview

**Objective:** <what this Feature achieves>
**User Value:** <specific benefit to users>
**Business Value:** <measurable business impact>

## Scope Definition

**In Scope:**

- <capability 1>
- <capability 2>
- <capability 3>

**Out of Scope:**

- <excluded capability 1>
- <excluded capability 2>

## Technical Architecture

**Components Involved:**

- API: <endpoints and services needed>
- Database: <tables and models>
- iOS: <screens and widgets>
- External Services: <Plaid, etc.>

**Integration Points:**

- <integration 1>
- <integration 2>

## Dependencies

**Feature Dependencies:**

- <Feature A> must be completed first
- <Feature B> can be developed in parallel

**Technical Dependencies:**

- <external service or library>
- <infrastructure requirement>

## Success Metrics

- <metric 1 from parent Epic>
- <metric 2 specific to this Feature>

## Next Steps

Ready for user story generation via feature-story-generator chatmode.

## Implementation Notes

<any technical considerations or constraints>

Placeholder Files for Story Generation

Create placeholder files that will be populated by feature-story-generator:

• user-stories.md - Will contain detailed user stories
• tech-notes.md - Will contain technical implementation details
• test-plan.md - Will contain testing approach
• dep.md - Will contain detailed dependency specifications

ScheduPay-Specific Feature Patterns

Financial Data Features

Always consider:

• Security: Encryption, access controls, audit trails
• Accuracy: Decimal precision, transaction categorization
• Privacy: User consent, data minimization, export/deletion
• Compliance: Financial regulations, data retention

iOS Widget Features

Always consider:

• Performance: Widget refresh rates, battery impact
• Glanceability: Information architecture, typography
• Accessibility: Dynamic Type, VoiceOver, contrast
• Update Frequency: Background refresh, timeline management

API Features

Always consider:

• Authentication: User sessions, token management
• Rate Limiting: Per-user and per-endpoint limits
• Error Handling: Graceful degradation, user-friendly messages
• Observability: Logging, metrics, tracing

Quality Gates

Before completing Epic triage:

• All Features deliver independent user value
• Feature boundaries are clear and non-overlapping
• Technical dependencies are identified and documented
• Requirements folder structure is created
• Each Feature is appropriately sized (3-8 stories)
• Integration points are defined
• Security and privacy considerations are noted
• Performance requirements are identified
• Feature-to-Feature dependencies are mapped

Output & Next Steps

Epic Triage Output

For each Epic, produces:

1. Feature Breakdown: Complete list of Features with clear scope
2. Requirements Structure: Created requirements/<feature-name>/ folders
3. Feature Documentation: Initial scope and architecture documentation
4. Dependency Analysis: Feature implementation order and dependencies
5. Technical Assessment: Architecture considerations and risks

Handoff to Story Generation

After Epic triage, use the feature-story-generator chatmode to:

1. Generate detailed user stories for each Feature
2. Create business acceptance criteria
3. Add technical specifications and constraints
4. Complete requirements documentation structure
5. Prepare Features for development implementation

Example Usage

# Triage a specific Epic
> Analyze "User Account Management" Epic and break down into Features

# Process multiple Epics
> Triage all MVP Epics from the epic generator output

# Focus on technical architecture
> Break down "Spending Insights" Epic with focus on iOS widget architecture

Operating Notes

• Feature Focus: Create Features that deliver complete user value independently
• Technical Alignment: Ensure Features align with ScheduPay's architecture patterns
• Dependency Awareness: Identify and document all Feature dependencies early
• Scope Discipline: Keep Feature scope focused and avoid "feature creep"
• Architecture Consideration: Always consider security, performance, and user experience
• Documentation Consistency: Use templates and follow ScheduPay documentation standards
• Story Preparation: Set up Features for efficient user story generation
• Implementation Readiness: Features should be ready for sprint planning after story generation

This chatmode ensures that Epic vision is properly broken down into implementable Features that engineering teams can plan, build, and deliver effectively.