BMAD-METHOD/expansion-packs/bmad-javascript-fullstack/tasks/create-development-story.md

Create Development Story Task

Purpose

Create detailed, actionable development stories for JavaScript/TypeScript full-stack features that enable developers to implement without additional design decisions.

When to Use

• Breaking down epics into implementable stories
• Converting architecture documents into development tasks
• Preparing work for sprint planning
• Ensuring clear handoffs from design to development

Prerequisites

Before creating stories, ensure you have:

• Completed architecture document
• PRD or feature requirements
• Epic definition this story belongs to
• Clear understanding of the specific feature

Process

1. Story Identification

Review Context:

• Understand the epic's overall goal
• Review architecture document sections
• Identify specific feature to implement
• Verify no duplicate work

Feature Analysis:

• Reference specific requirements
• Understand user experience goals
• Identify technical complexity
• Estimate implementation scope (1-3 days ideal)

2. Story Scoping

Single Responsibility:

• Focus on one specific feature or component
• Ensure story is completable in 1-3 days
• Break down complex features into multiple stories
• Maintain clear boundaries with other stories

Implementation Clarity:

• Define exactly what needs to be built
• Specify all technical requirements
• Include all necessary integration points
• Provide clear success criteria

3. Template Execution

Use Template: Use templates/stories/javascript-development-story.md template

Key Focus Areas:

• Clear, actionable description with user story format
• Specific acceptance criteria (functional, technical, security)
• Detailed technical specifications
• Complete implementation task list
• Comprehensive testing requirements
• Type definitions and interfaces

4. Story Validation

Technical Review:

• Verify all technical specifications are complete
• Ensure integration points are clearly defined
• Confirm file paths and structure
• Validate TypeScript interfaces

Architecture Alignment:

• Confirm story implements architecture requirements
• Verify technology choices match architecture doc
• Check database changes align with schema
• Ensure API contracts are consistent

Implementation Readiness:

• All dependencies identified and listed
• Asset requirements specified if needed
• Testing criteria defined
• Definition of Done complete

5. Quality Assurance

Apply Checklist: Execute checklists/story-dod-checklist.md against completed story

Story Criteria:

• Story is immediately actionable
• No design decisions left to developer
• Technical requirements are complete
• Testing requirements are comprehensive
• Security requirements specified

6. Story Refinement

Developer Perspective:

• Can a developer start implementation immediately?
• Are all technical questions answered?
• Is the scope appropriate for the estimated points?
• Are all dependencies clearly identified?

Iterative Improvement:

• Address any gaps or ambiguities
• Clarify complex technical requirements
• Ensure story fits within epic scope
• Verify story points estimation (1, 2, 3, 5, 8)

Story Elements Checklist

Required Sections

• Clear user story (As a, I want, So that)
• Complete acceptance criteria (functional, technical)
• Detailed technical specifications
• File creation/modification list
• TypeScript interfaces and types
• Integration point specifications
• Ordered implementation tasks
• Comprehensive testing requirements
• Performance criteria
• Security considerations
• Dependencies clearly identified
• Definition of Done checklist

Full-Stack Considerations

• Frontend changes (if applicable)
• Backend changes (if applicable)
• API contract (if applicable)
• Database migrations (if applicable)
• Both client and server validation
• Error handling on both layers
• Loading states and user feedback

Technical Quality

• TypeScript strict mode compliance
• Architecture document alignment
• Code organization follows standards
• Error handling requirements
• Logging requirements
• Testing strategy defined

Common Pitfalls

Scope Issues:

• Story too large (break into multiple stories - 1-3 days max)
• Story too vague (add specific requirements)
• Missing dependencies (identify all prerequisites)
• Unclear boundaries (define what's in/out of scope)

Technical Issues:

• Missing integration details (API contracts, events)
• Incomplete technical specifications
• Undefined TypeScript interfaces
• Missing performance requirements
• No error handling specified

Full-Stack Coordination:

• Frontend and backend changes not aligned
• API contract not defined
• Database changes not included
• Missing validation on both layers

Success Criteria

Story Readiness:

• Developer can start implementation immediately
• No additional design decisions required
• All technical questions answered
• Testing strategy is complete
• Performance requirements are clear
• Security requirements specified
• Story fits within epic scope
• Estimated effort realistic (1-3 days)

Quality Validation:

• Story DOD checklist passes
• Architecture alignment confirmed
• Requirements covered
• Implementation tasks are ordered and specific
• Dependencies are complete and accurate

Handoff Protocol

To Developer:

1. Provide story document
2. Confirm access to architecture docs and requirements
3. Verify all dependencies are met
4. Answer any clarification questions
5. Establish check-in schedule

Story Status Updates:

• To Do → In Development
• In Development → Code Review
• Code Review → QA Testing
• QA Testing → Done

Story Template Sections

Header:

• Story ID, Epic, Sprint, Assignee, Status, Priority, Effort

Description:

• User story format
• Background and context
• Goals

Acceptance Criteria:

• Functional requirements (user-facing)
• Technical requirements (code quality)
• Performance requirements
• Security requirements

Technical Specification:

• Frontend implementation (components, hooks, state)
• Backend implementation (endpoints, services, database)
• TypeScript types and interfaces
• Integration points

Testing:

• Unit tests required
• Integration tests required
• E2E tests if critical flow
• Manual testing checklist

Dependencies:

• Blocked by (must complete first)
• Blocks (what depends on this)
• Related stories

This task ensures development stories are comprehensive, actionable, and enable efficient implementation of full-stack JavaScript features.