Agent skill

gmacko-dev-feature-plan

Use when (1) breaking down a feature request into implementable tasks, (2) creating a detailed feature specification, (3) preparing work for development. Generates feature plans with acceptance criteria and task breakdown.

View SKILL.md on GitHub Repository
Stars 163
Forks 31

Install this agent skill to your Project

npx add-skill https://github.com/majiayu000/claude-skill-registry/tree/main/skills/development/gmacko-dev-feature-plan

Metadata

Additional technical details for this skill

tier
workhorse
phase
development
permission
allow

SKILL.md

Gmacko Feature Planning

Break down feature requests into detailed implementation plans with tasks and acceptance criteria.

When to Use

  • User describes a new feature to implement
  • A GitHub issue needs task breakdown
  • Planning sprint work
  • Converting INITIAL_PLAN.md milestones into actionable tasks

Workflow

dot
digraph feature_plan {
    rankdir=TB;
    node [shape=box];
    
    start [label="Start" shape=ellipse];
    gather [label="1. Gather Context"];
    analyze [label="2. Analyze Requirements"];
    breakdown [label="3. Break Down Tasks"];
    criteria [label="4. Define Acceptance Criteria"];
    estimate [label="5. Estimate Effort"];
    review [label="6. Review with User"];
    approved [label="Approved?" shape=diamond];
    write [label="7. Write Plan Document"];
    issues [label="8. Suggest Issues"];
    done [label="Planning Complete" shape=ellipse];
    
    start -> gather -> analyze -> breakdown;
    breakdown -> criteria -> estimate -> review -> approved;
    approved -> write [label="yes"];
    approved -> analyze [label="revise"];
    write -> issues -> done;
}

Execution Steps

Step 1: Gather Context

Before planning, gather necessary context:

Questions to Ask:

  1. What is the feature name/title?
  2. What problem does it solve?
  3. Which platforms are affected? (web/mobile/api/all)
  4. Is this in the INITIAL_PLAN.md? If so, which milestone?
  5. Any existing related code to reference?
  6. Any design mockups or references?
  7. Are there dependencies on other features?

Files to Check:

  • INITIAL_PLAN.md - For context on planned features
  • PROJECT_MANIFEST.json - For enabled integrations
  • packages/db/src/schema.ts - For existing data model
  • packages/api/src/routers/ - For existing API patterns

Step 2: Analyze Requirements

Break down the feature into components:

markdown
## Feature Analysis

### User Stories
- As a [user type], I want [capability] so that [benefit]

### Affected Areas
- [ ] Database schema changes
- [ ] API endpoints (tRPC routers)
- [ ] Web UI components
- [ ] Mobile UI components
- [ ] Shared package updates
- [ ] Third-party integrations

### Technical Considerations
- Authentication required: yes/no
- Real-time updates needed: yes/no
- Analytics events to track: [list]
- Error states to handle: [list]

Step 3: Break Down Tasks

Create a hierarchical task breakdown:

markdown
## Task Breakdown

### 1. Database Layer
- [ ] Add/modify schema in `packages/db/src/schema.ts`
- [ ] Create migration
- [ ] Add indexes if needed

### 2. API Layer
- [ ] Create/update tRPC router in `packages/api/src/routers/`
- [ ] Add input validation (Zod schemas)
- [ ] Implement business logic
- [ ] Add error handling

### 3. Web UI
- [ ] Create page/component in `apps/web/src/`
- [ ] Connect to tRPC hooks
- [ ] Add loading/error states
- [ ] Implement responsive design

### 4. Mobile UI (if applicable)
- [ ] Create screen/component in `apps/mobile/src/`
- [ ] Connect to tRPC hooks
- [ ] Handle platform-specific UI

### 5. Integration
- [ ] Add analytics events
- [ ] Add error tracking
- [ ] Update i18n strings

### 6. Testing & QA
- [ ] Write test cases
- [ ] Manual testing checklist
- [ ] Cross-platform verification

Step 4: Define Acceptance Criteria

Write clear, testable acceptance criteria:

markdown
## Acceptance Criteria

### Functional
- [ ] User can [action 1]
- [ ] System displays [expected behavior]
- [ ] Data is persisted correctly
- [ ] Errors are handled gracefully

### Non-Functional
- [ ] Page loads in < 2 seconds
- [ ] Works on mobile viewports
- [ ] Accessible (keyboard navigation, screen readers)
- [ ] No console errors

### Edge Cases
- [ ] Empty state handled
- [ ] Maximum limits respected
- [ ] Concurrent access handled

Step 5: Estimate Effort

Provide rough estimates:

Task Estimate Complexity
Database changes 1h Low
API implementation 2h Medium
Web UI 4h Medium
Mobile UI 3h Medium
Testing 2h Low
Total 12h -

Step 6: Review with User

Present the plan summary:

Feature Plan: [Feature Name]

Summary: [One sentence description]

Scope:

  • Platforms: [Web/Mobile/Both]
  • Dependencies: [None/List]
  • Estimated effort: [X hours]

Tasks: [X] tasks across [Y] areas

Does this look complete? Should I adjust anything?

Step 7: Write Plan Document

Write to docs/ai/handoffs/{feature-id}-plan.md:

markdown
# Feature Plan: [Feature Name]

> Generated on [date]
> Author: AI Assistant

## Overview

**Feature**: [Name]
**Issue**: #[number] (if exists)
**Milestone**: [From INITIAL_PLAN.md]
**Estimated Effort**: [X hours]

## Problem Statement

[What problem this solves]

## User Stories

- As a [user], I want [goal] so that [benefit]

## Technical Design

### Data Model Changes

```typescript
// New/modified schema

API Changes

typescript
// New/modified procedures

UI Components

  • Web: [List of components]
  • Mobile: [List of screens] (if applicable)

Task Breakdown

[Detailed task list from Step 3]

Acceptance Criteria

[Criteria from Step 4]

Test Plan

Manual Testing

  1. [Test case 1]
  2. [Test case 2]

Automated Testing

  • Unit tests for [component]
  • Integration tests for [API]

Dependencies

  • Requires: [Other features/issues]
  • Blocks: [Dependent features]

Rollback Plan

If issues arise:

  1. [Rollback step 1]
  2. [Rollback step 2]

Open Questions

  • [Question 1]
  • [Question 2]

### Step 8: Suggest Issues

Recommend GitHub issue creation:

> Based on this plan, I recommend creating these issues:
>
> 1. **[Feature]: [Main feature name]** - Epic/parent issue
> 2. **[Task]: Database schema for [feature]** - Subtask
> 3. **[Task]: API endpoints for [feature]** - Subtask
> 4. **[Task]: Web UI for [feature]** - Subtask
>
> Would you like me to create these issues using `gmacko-dev-issue-create`?

## Output Artifacts

- `docs/ai/handoffs/{feature-id}-plan.md` - Detailed plan
- Suggested GitHub issues (optional)

## Red Flags

| Rationalization | Correction |
|-----------------|------------|
| "This is simple, no need for a plan" | ALL features get plans; even small ones |
| "I'll skip acceptance criteria" | Criteria are required for QA handoff |
| "User knows what they want, no questions needed" | ALWAYS gather context first |
| "Estimates don't matter" | Estimates help prioritization |

## Integration Points

- **Input**: Feature request (verbal or issue)
- **References**: `INITIAL_PLAN.md`, `PROJECT_MANIFEST.json`
- **Output**: `docs/ai/handoffs/{id}-plan.md`
- **Next**: `gmacko-dev-issue-create` or direct implementation

Didn't find tool you were looking for?

Be as detailed as possible for better results