ros/BMAD-METHOD
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

agent team workflows

Browse Source
This commit is contained in:
Brian Madison
2025-06-08 17:34:38 -05:00
parent 54406fa871
commit f1fa6256f0
31 changed files with 2280 additions and 938 deletions
Download Patch File Download Diff File Expand all files Collapse all files

188
agent-team-workflows/api-only.yml Normal file
View File

@@ -0,0 +1,188 @@
workflow:
id: api-only
name: API-First Development
description: >-
Workflow for building REST APIs, GraphQL services, or microservices
without frontend components.
type: greenfield
project_types:
- rest-api
- graphql-api
- microservice
- backend-service
stages:
- id: api-discovery
name: API Requirements Discovery
description: Understand API consumers and requirements
steps:
- agent: analyst
action: API Requirements Analysis
description: >-
Analyze API consumers, use cases, and integration requirements
outputs:
- api-requirements
- consumer-analysis
prompts:
- "Who will consume this API? Internal services, mobile apps, third parties?"
- "What are the main operations and data flows?"
- id: api-design
name: API Product Design
description: Design API as a product
steps:
- agent: pm
action: API Product Strategy
description: >-
Define API product strategy, versioning, and roadmap
inputs:
- api-requirements
outputs:
- api-product-spec
- api-roadmap
prompts:
- "What's the API versioning strategy?"
- "How will the API evolve over time?"
- agent: architect
action: API Architecture Design
description: >-
Design RESTful resources, GraphQL schema, or service contracts
inputs:
- api-product-spec
outputs:
- api-design-doc
- openapi-spec
- data-contracts
prompts:
- "Let's design the API endpoints and data models"
- "Define authentication and authorization strategy"
- id: technical-design
name: Technical Architecture
description: Design backend architecture and infrastructure
steps:
- agent: architect
action: Backend Architecture
description: >-
Design service architecture, database, and integrations
inputs:
- api-design-doc
outputs:
- backend-architecture
- database-design
- integration-architecture
prompts:
- "Design the service layer architecture"
- "What databases and caching strategies?"
- agent: devops
action: API Infrastructure
description: >-
Design API gateway, rate limiting, monitoring, and deployment
inputs:
- backend-architecture
outputs:
- api-infrastructure
- monitoring-strategy
- deployment-plan
prompts:
- "Design API gateway and rate limiting"
- "Define monitoring and alerting strategy"
- id: validation
name: API Design Validation
description: Validate API design and documentation
steps:
- agent: po
action: API Design Review
description: >-
Review API design for completeness and usability
inputs:
- api-design-doc
- openapi-spec
outputs:
- api-validation-report
- api-documentation
prompts:
- "Review API design for developer experience"
- "Is the API documentation complete?"
- id: development-planning
name: Implementation Planning
description: Plan API implementation sprints
steps:
- agent: sm
action: API Development Stories
description: >-
Create stories for endpoints, middleware, and infrastructure
inputs:
- api-design-doc
- backend-architecture
outputs:
- api-stories
- implementation-plan
prompts:
- "Break down API into implementation stories"
- "Prioritize endpoints for phased delivery"
- agent: qa
action: API Test Planning
description: >-
Create API testing strategy and automation plan
inputs:
- openapi-spec
- api-stories
outputs:
- api-test-strategy
- contract-tests
- performance-tests
prompts:
- "Design API contract testing approach"
- "Plan load testing and performance benchmarks"
- id: developer-experience
name: Developer Experience
description: Prepare API for developers
steps:
- agent: dev
action: SDK & Documentation Planning
description: >-
Plan SDK development and interactive documentation
inputs:
- openapi-spec
- api-documentation
outputs:
- sdk-requirements
- doc-portal-plan
prompts:
- "Which language SDKs are needed?"
- "Plan interactive API documentation"
transitions:
- from: api-discovery
to: api-design
condition: requirements analyzed
- from: api-design
to: technical-design
condition: api spec completed
- from: technical-design
to: validation
condition: architecture completed
- from: validation
to: development-planning
condition: design approved
- from: development-planning
to: developer-experience
condition: stories created
artifacts:
openapi-spec:
format: openapi-3.0
description: Complete API specification
api-design-doc:
template: api-design-tmpl
description: API design decisions and patterns
contract-tests:
format: postman-collection
description: API contract test suite

229
agent-team-workflows/backend-service.yml Normal file
View File

@@ -0,0 +1,229 @@
workflow:
id: backend-service
name: Backend Service Development
description: >-
Workflow for building microservices, backend APIs, or data processing services
with focus on scalability, reliability, and maintainability.
type: greenfield
project_types:
- microservice
- data-pipeline
- background-worker
- event-processor
stages:
- id: service-discovery
name: Service Requirements
description: Define service boundaries and responsibilities
steps:
- agent: analyst
action: Service Analysis
description: >-
Analyze service requirements, boundaries, and integrations
outputs:
- service-brief
- integration-requirements
- data-flow-analysis
prompts:
- "What is this service's primary responsibility?"
- "What other services will it interact with?"
- "What are the data input/output requirements?"
- id: service-design
name: Service Design
description: Design service architecture and contracts
steps:
- agent: architect
action: Service Architecture
description: >-
Design service internals, API contracts, and data models
inputs:
- service-brief
- integration-requirements
outputs:
- service-architecture
- api-contracts
- event-schemas
- data-models
prompts:
- "Design the service architecture pattern"
- "Define API contracts and event schemas"
- "Choose appropriate data storage solutions"
- agent: architect
action: Integration Design
description: >-
Design service mesh, messaging, and integration patterns
inputs:
- service-architecture
- integration-requirements
outputs:
- integration-architecture
- messaging-patterns
- service-mesh-config
prompts:
- "Design inter-service communication"
- "Choose messaging patterns (sync/async)"
- "Define service discovery approach"
- id: reliability-design
name: Reliability & Performance
description: Design for production reliability
steps:
- agent: devops
action: Production Architecture
description: >-
Design deployment, scaling, and reliability features
inputs:
- service-architecture
outputs:
- deployment-architecture
- scaling-strategy
- reliability-patterns
- observability-design
prompts:
- "Design auto-scaling and load balancing"
- "Plan fault tolerance and circuit breakers"
- "Design comprehensive observability"
- agent: architect
action: Performance Design
description: >-
Design caching, optimization, and performance strategies
inputs:
- service-architecture
- data-flow-analysis
outputs:
- performance-architecture
- caching-strategy
- query-optimization
prompts:
- "Identify performance bottlenecks"
- "Design caching layers"
- "Optimize data access patterns"
- id: security-design
name: Security Architecture
description: Design security controls and compliance
steps:
- agent: architect
action: Security Design
description: >-
Design authentication, authorization, and data security
inputs:
- service-architecture
- api-contracts
outputs:
- security-architecture
- auth-design
- encryption-strategy
- compliance-controls
prompts:
- "Design authentication and authorization"
- "Plan data encryption at rest and in transit"
- "Address compliance requirements"
- id: validation
name: Architecture Validation
description: Validate complete service design
steps:
- agent: po
action: Service Design Review
description: >-
Review service design for completeness and alignment
inputs:
- service-architecture
- integration-architecture
- security-architecture
outputs:
- design-approval
- risk-assessment
prompts:
- "Review service boundaries and responsibilities"
- "Validate non-functional requirements"
- id: implementation-planning
name: Implementation Planning
description: Plan service implementation
steps:
- agent: sm
action: Service Implementation Stories
description: >-
Create implementation stories with clear boundaries
inputs:
- service-architecture
- api-contracts
outputs:
- implementation-stories
- api-development-plan
- integration-test-plan
prompts:
- "Break down into implementation stories"
- "Define story dependencies"
- "Plan incremental delivery"
- agent: qa
action: Service Testing Strategy
description: >-
Design testing strategy for distributed systems
inputs:
- service-architecture
- integration-architecture
outputs:
- test-strategy
- contract-testing-plan
- chaos-testing-plan
- performance-test-plan
prompts:
- "Design contract testing approach"
- "Plan chaos engineering tests"
- "Define performance benchmarks"
- id: operational-readiness
name: Operational Readiness
description: Prepare for production deployment
steps:
- agent: devops
action: Production Readiness
description: >-
Create runbooks, monitoring, and deployment procedures
inputs:
- deployment-architecture
- observability-design
outputs:
- runbooks
- monitoring-dashboards
- alert-rules
- deployment-procedures
prompts:
- "Create operational runbooks"
- "Design monitoring dashboards"
- "Define SLIs and SLOs"
transitions:
- from: service-discovery
to: service-design
condition: requirements defined
- from: service-design
to: reliability-design
condition: architecture completed
- from: reliability-design
to: security-design
condition: reliability planned
- from: security-design
to: validation
condition: security designed
- from: validation
to: implementation-planning
condition: design approved
- from: implementation-planning
to: operational-readiness
condition: stories created
key_artifacts:
- Service architecture document
- API contracts and schemas
- Integration architecture
- Security controls
- Operational runbooks
- Test strategies

193
agent-team-workflows/brownfield-enhancement.yml Normal file
View File

@@ -0,0 +1,193 @@
workflow:
id: brownfield-enhancement
name: Brownfield Enhancement
description: >-
Workflow for adding features, refactoring, or modernizing existing applications.
Handles legacy code analysis and incremental improvements.
type: brownfield
project_types:
- feature-addition
- refactoring
- modernization
- bug-fix
stages:
- id: system-analysis
name: Existing System Analysis
description: Understand current system and identify improvement areas
steps:
- agent: analyst
action: System Assessment
description: >-
Analyze existing system, codebase, and identify pain points
inputs:
- existing-documentation
- codebase-access
outputs:
- system-assessment
- improvement-opportunities
- technical-debt-analysis
prompts:
- "Let's analyze the existing system architecture"
- "What are the main pain points and technical debt?"
- "Share any existing documentation or system diagrams"
- "You can also share the codebase if you have access to it"
- agent: dev
action: Code Analysis
description: >-
Deep dive into codebase quality and structure
inputs:
- codebase-access
outputs:
- code-quality-report
- dependency-analysis
- refactoring-candidates
prompts:
- "Let me analyze the code structure and quality"
- "Identifying areas that need refactoring"
- id: enhancement-planning
name: Enhancement Planning
description: Plan improvements and new features
steps:
- agent: pm
action: Enhancement Strategy
description: >-
Define enhancement goals and success criteria
inputs:
- system-assessment
- improvement-opportunities
outputs:
- enhancement-prd
- success-metrics
- risk-assessment
prompts:
- "What specific enhancements are we targeting?"
- "Define success metrics for these improvements"
- agent: architect
action: Integration Architecture
description: >-
Design how new features integrate with existing system
inputs:
- enhancement-prd
- system-assessment
outputs:
- integration-architecture
- migration-strategy
- compatibility-matrix
prompts:
- "How will new features integrate with existing code?"
- "Design migration strategy for gradual rollout"
- id: incremental-design
name: Incremental Design
description: Design changes that don't break existing functionality
steps:
- agent: fullstack-architect
action: Incremental Architecture
description: >-
Design architecture that allows gradual migration
inputs:
- integration-architecture
- technical-debt-analysis
outputs:
- incremental-architecture
- feature-flags-design
- rollback-strategy
prompts:
- "Design architecture for incremental deployment"
- "How do we maintain backward compatibility?"
- agent: devops
action: Deployment Strategy
description: >-
Plan zero-downtime deployment and rollback procedures
inputs:
- incremental-architecture
outputs:
- deployment-strategy
- canary-release-plan
- monitoring-upgrades
prompts:
- "Design blue-green or canary deployment"
- "Upgrade monitoring for new features"
- id: risk-mitigation
name: Risk Assessment & Mitigation
description: Identify and plan for risks in brownfield changes
steps:
- agent: qa
action: Regression Risk Analysis
description: >-
Identify regression risks and test coverage gaps
inputs:
- code-quality-report
- integration-architecture
outputs:
- regression-risk-matrix
- test-gap-analysis
- test-automation-plan
prompts:
- "What existing functionality might break?"
- "Where do we need additional test coverage?"
- agent: po
action: Change Impact Review
description: >-
Review all changes for business impact
inputs:
- enhancement-prd
- risk-assessment
- regression-risk-matrix
outputs:
- impact-analysis
- stakeholder-communication
- approval-checklist
prompts:
- "Review impact on existing users and workflows"
- "Prepare stakeholder communication plan"
- id: implementation-planning
name: Phased Implementation
description: Create phased implementation plan
steps:
- agent: sm
action: Phased Story Creation
description: >-
Create stories for incremental implementation
inputs:
- incremental-architecture
- impact-analysis
outputs:
- implementation-phases
- user-stories
- dependency-map
prompts:
- "Break down into safe, incremental phases"
- "Map dependencies between stories"
transitions:
- from: system-analysis
to: enhancement-planning
condition: assessment complete
- from: enhancement-planning
to: incremental-design
condition: strategy defined
- from: incremental-design
to: risk-mitigation
condition: architecture approved
- from: risk-mitigation
to: implementation-planning
condition: risks assessed
special_considerations:
- name: Legacy Code
description: Handle undocumented or poorly structured code
- name: Data Migration
description: Plan for data structure changes
- name: User Training
description: Consider impact on existing users
- name: Rollback Plan
description: Always have a way to revert changes

219
agent-team-workflows/frontend-only.yml Normal file
View File

@@ -0,0 +1,219 @@
workflow:
id: frontend-only
name: Frontend Application Development
description: >-
Workflow for building frontend applications that consume existing APIs.
Perfect for SPAs, mobile apps, or micro-frontends.
type: greenfield
project_types:
- spa
- mobile-app
- micro-frontend
- static-site
stages:
- id: frontend-discovery
name: Frontend Requirements
description: Understand user needs and API constraints
steps:
- agent: analyst
action: Frontend Analysis
description: >-
Analyze user needs, existing APIs, and frontend requirements
inputs:
- api-documentation
- user-requirements
outputs:
- frontend-brief
- api-integration-plan
prompts:
- "What APIs will the frontend consume?"
- "What are the key user interactions?"
- id: ux-design
name: User Experience Design
description: Design complete user experience
steps:
- agent: ux-expert
action: Complete UX Process
description: >-
User research, personas, flows, wireframes, and prototypes
inputs:
- frontend-brief
outputs:
- user-research
- personas
- user-flows
- wireframes
- interactive-prototype
prompts:
- "Let's understand your users deeply"
- "Design the complete user journey"
- agent: ux-expert
action: Visual Design
description: >-
Create visual designs and style guide
inputs:
- wireframes
- brand-guidelines
outputs:
- visual-designs
- style-guide
- design-tokens
prompts:
- "Create the visual language"
- "Define colors, typography, and spacing"
- id: frontend-architecture
name: Frontend Technical Design
description: Design frontend architecture and components
steps:
- agent: ui-architect
action: Frontend Architecture
description: >-
Design component architecture, state management, and routing
inputs:
- interactive-prototype
- api-integration-plan
outputs:
- frontend-architecture
- component-hierarchy
- state-management-design
- routing-design
prompts:
- "Design the frontend architecture"
- "Choose framework and design patterns"
- agent: ui-architect
action: Component Design System
description: >-
Create detailed component specifications and AI generation prompts
inputs:
- visual-designs
- design-tokens
outputs:
- component-library-spec
- ai-generation-prompts
- accessibility-guidelines
prompts:
- "Design reusable component system"
- "Create prompts for AI UI generation"
- id: api-integration
name: API Integration Planning
description: Plan API integration and data flow
steps:
- agent: fullstack-architect
action: Integration Architecture
description: >-
Design API integration, data fetching, and caching strategies
inputs:
- api-documentation
- frontend-architecture
outputs:
- integration-patterns
- data-flow-design
- error-handling-strategy
- caching-strategy
prompts:
- "Design efficient API integration"
- "Plan offline capabilities if needed"
- id: performance-planning
name: Performance & Optimization
description: Plan for optimal performance
steps:
- agent: ui-architect
action: Performance Strategy
description: >-
Design performance optimization and PWA features
inputs:
- frontend-architecture
outputs:
- performance-budget
- optimization-strategy
- pwa-features
prompts:
- "Set performance budgets"
- "Plan lazy loading and code splitting"
- id: validation
name: Design Validation
description: Validate all frontend designs
steps:
- agent: po
action: Frontend Validation
description: >-
Validate UX, technical design, and accessibility
inputs:
- visual-designs
- frontend-architecture
- component-library-spec
outputs:
- design-approval
- accessibility-review
prompts:
- "Review all designs for consistency"
- "Validate accessibility compliance"
- id: development-planning
name: Frontend Development Planning
description: Plan implementation sprints
steps:
- agent: sm
action: Frontend Stories
description: >-
Create component and feature stories
inputs:
- component-library-spec
- frontend-architecture
outputs:
- component-stories
- feature-stories
- sprint-plan
prompts:
- "Break down into component stories"
- "Plan progressive enhancement"
- agent: qa
action: Frontend Testing Strategy
description: >-
Plan unit, integration, and E2E testing
inputs:
- component-stories
- user-flows
outputs:
- test-strategy
- e2e-test-scenarios
- visual-regression-tests
prompts:
- "Design component testing approach"
- "Plan E2E test scenarios"
transitions:
- from: frontend-discovery
to: ux-design
condition: requirements understood
- from: ux-design
to: frontend-architecture
condition: designs completed
- from: frontend-architecture
to: api-integration
condition: architecture defined
- from: api-integration
to: performance-planning
condition: integration planned
- from: performance-planning
to: validation
condition: optimization planned
- from: validation
to: development-planning
condition: designs approved
deliverables:
- Interactive prototype
- Component library specification
- AI UI generation prompts
- Frontend architecture document
- Performance optimization plan

227
agent-team-workflows/fullstack-app.yml Normal file
View File

@@ -0,0 +1,227 @@
workflow:
id: fullstack-app
name: Full-Stack Application Development
description: >-
Comprehensive workflow for building production-ready full-stack applications
with emphasis on UI/UX and scalable architecture.
type: greenfield
project_types:
- web-app
- saas
- enterprise-app
stages:
- id: discovery
name: Discovery & Analysis
description: Deep dive into requirements and market analysis
steps:
- agent: analyst
action: Market & Requirements Analysis
description: >-
Analyze market, competitors, and gather detailed requirements
outputs:
- project-brief
- market-analysis
prompts:
- "Let's analyze the market landscape for your application"
- "What are your competitive advantages?"
- id: product-design
name: Product Design
description: Create comprehensive product specifications
steps:
- agent: pm
action: Create Detailed PRD
description: >-
Create comprehensive PRD with user stories and success metrics
inputs:
- project-brief
- market-analysis
outputs:
- prd
- success-metrics
prompts:
- "Let's define detailed features and user stories"
- "What metrics will measure success?"
- agent: ux-expert
action: Complete UX Design
description: >-
Create user research, personas, flows, and detailed wireframes
inputs:
- prd
outputs:
- user-personas
- user-flows
- wireframes
- ui-specifications
prompts:
- "Let's create detailed user personas"
- "Time to design the complete user experience"
- id: ui-development
name: UI Design & Prototyping
description: Create high-fidelity designs and interactive prototypes
steps:
- agent: ui-architect
action: UI Architecture & Design System
description: >-
Create design system, component library specs, and UI architecture
inputs:
- wireframes
- ui-specifications
outputs:
- design-system
- component-specs
- ui-architecture
prompts:
- "Let's create a scalable design system"
- "Define reusable component architecture"
- agent: ux-expert
action: Generate UI Components
description: >-
Create AI prompts and generate actual UI components
inputs:
- design-system
- component-specs
outputs:
- ui-generation-prompts
- generated-components
prompts:
- "Let's create prompts for AI UI generation"
- "Generate the core UI components"
- id: technical-architecture
name: System Architecture
description: Design complete technical architecture
steps:
- agent: fullstack-architect
action: System Architecture Design
description: >-
Design complete system including microservices, APIs, and infrastructure
inputs:
- prd
- ui-architecture
outputs:
- system-architecture
- api-specifications
- data-models
prompts:
- "Design the complete system architecture"
- "Define API contracts and data models"
- agent: architect
action: Backend Architecture
description: >-
Detail backend services, integrations, and technical specifications
inputs:
- system-architecture
- api-specifications
outputs:
- backend-architecture
- integration-specs
prompts:
- "Detail the backend service architecture"
- "Define third-party integrations"
- agent: devops
action: Infrastructure Design
description: >-
Design cloud infrastructure, CI/CD, and deployment architecture
inputs:
- system-architecture
outputs:
- infrastructure-design
- deployment-architecture
- ci-cd-pipeline
prompts:
- "Design the cloud infrastructure"
- "Create CI/CD pipeline specifications"
- id: validation
name: Comprehensive Validation
description: Validate all artifacts and ensure alignment
steps:
- agent: po
action: Full Artifact Validation
description: >-
Validate all documents, ensure alignment, and approve for development
inputs:
- prd
- system-architecture
- ui-architecture
- infrastructure-design
outputs:
- validation-report
- approved-artifacts
prompts:
- "Complete validation of all artifacts"
- "Any final adjustments needed?"
- id: development-planning
name: Sprint Planning
description: Create detailed development plan and stories
steps:
- agent: sm
action: Create Sprint Plan
description: >-
Create epics, user stories, and detailed sprint plan
inputs:
- approved-artifacts
outputs:
- epics
- user-stories
- sprint-plan
- definition-of-done
prompts:
- "Let's break this into epics and stories"
- "Create the sprint roadmap"
- id: quality-planning
name: Quality Assurance Planning
description: Define testing strategy and quality metrics
steps:
- agent: qa
action: Test Strategy & Planning
description: >-
Create comprehensive test strategy and automation plan
inputs:
- prd
- system-architecture
- user-stories
outputs:
- test-strategy
- test-cases
- automation-plan
prompts:
- "Define the testing strategy"
- "Plan test automation approach"
transitions:
- from: discovery
to: product-design
condition: project-brief completed
- from: product-design
to: ui-development
condition: prd and wireframes completed
- from: ui-development
to: technical-architecture
condition: ui components designed
- from: technical-architecture
to: validation
condition: all architecture completed
- from: validation
to: development-planning
condition: artifacts approved
- from: development-planning
to: quality-planning
condition: stories created
checkpoints:
- after: product-design
review: Stakeholder review of PRD and UX
- after: technical-architecture
review: Architecture review board
- after: validation
review: Final go/no-go decision

179
agent-team-workflows/greenfield-mvp.yml Normal file
View File

@@ -0,0 +1,179 @@
workflow:
id: greenfield-mvp
name: Greenfield MVP Development
description: >-
Complete workflow for building a new MVP from scratch. Takes you from initial
idea through planning, architecture, and development setup.
type: greenfield
project_types:
- web-app
- mobile-app
- full-stack
- app with microservice rest api
stages:
- id: discovery
name: Discovery & Requirements
description: Understand the problem space and gather requirements
steps:
- agent: analyst
action: Create Project Brief
description: >-
Brainstorm and document the project vision, goals, and high-level requirements
outputs:
- project-brief
prompts:
- "Let's explore your project idea. What problem are you trying to solve?"
- "Who are your target users and what are their main pain points?"
- id: planning
name: Product Planning
description: Define the product and create detailed requirements
steps:
- agent: pm
action: Create PRD
description: >-
Transform the project brief into a comprehensive Product Requirements Document
inputs:
- project-brief
outputs:
- prd
prompts:
- "Based on the project brief, let's define the MVP features"
- "What are the must-have features vs nice-to-have for launch?"
- agent: ux-expert
action: Design UX Strategy
description: >-
Create user flows, wireframes, and UI specifications
inputs:
- prd
outputs:
- ux-strategy
- ui-specifications
prompts:
- "Let's map out the user journey for the core features"
- "What UI patterns best serve your users' needs?"
- id: architecture
name: Technical Architecture
description: Design the system architecture and technical approach
steps:
- agent: fullstack-architect
action: Create Architecture Document
description: >-
Design comprehensive system architecture covering all layers
inputs:
- prd
- ui-specifications
outputs:
- architecture-doc
prompts:
- "Let's design a scalable architecture for your MVP"
- "What are your performance and scaling requirements?"
- agent: ui-architect
action: Create Frontend Architecture
description: >-
Detail the frontend architecture and component design
inputs:
- architecture-doc
- ui-specifications
outputs:
- frontend-architecture
- ui-prompt-specs
prompts:
- "Let's define the frontend stack and component architecture"
- "Should we generate UI components with AI assistance?"
- id: validation
name: Validation & Refinement
description: Review and validate all planning artifacts
steps:
- agent: po
action: Validate Artifacts
description: >-
Review all documents for consistency and completeness
inputs:
- project-brief
- prd
- architecture-doc
- frontend-architecture
outputs:
- validation-report
- change-requests
prompts:
- "Let's review all artifacts for consistency"
- "Are there any gaps or conflicts to address?"
- id: development-planning
name: Development Planning
description: Create actionable development stories
steps:
- agent: sm
action: Create User Stories
description: >-
Break down requirements into sprint-ready user stories
inputs:
- prd
- architecture-doc
- validation-report
outputs:
- user-stories
- sprint-plan
prompts:
- "Let's create the first sprint's user stories"
- "How should we prioritize the backlog?"
- id: development-handoff
name: Development Handoff
description: Transition to implementation phase
steps:
- agent: dev
action: Development Setup
description: >-
Review all artifacts and set up development environment
inputs:
- architecture-doc
- frontend-architecture
- user-stories
outputs:
- dev-environment
- implementation-plan
prompts:
- "Let's set up the development environment"
- "Ready to start implementing the first story?"
transitions:
- from: discovery
to: planning
condition: project-brief completed
- from: planning
to: architecture
condition: prd and ui-specifications completed
- from: architecture
to: validation
condition: all architecture docs completed
- from: validation
to: development-planning
condition: validation passed
- from: development-planning
to: development-handoff
condition: stories created
artifacts:
project-brief:
template: project-brief-tmpl
description: High-level project vision and goals
prd:
template: prd-tmpl
description: Detailed product requirements
architecture-doc:
template: fullstack-architecture-tmpl
description: Complete system architecture
frontend-architecture:
template: front-end-architecture-tmpl
description: Frontend-specific architecture
user-stories:
template: story-tmpl
description: Development-ready user stories