Implementation Workflow Generator

Analyze Product Requirements Documents (PRDs) and feature specifications to generate comprehensive, step-by-step implementation workflows with expert guidance, dependency mapping, and automated task orchestration.

When to use

• Planning feature implementation from PRDs
• Creating development roadmaps
• Breaking down complex features into tasks
• Generating sprint plans
• Coordinating multi-team implementation efforts

Instructions

Usage

/sc:workflow [prd-file|feature-description] [--persona expert] [--c7] [--sequential] [--strategy systematic|agile|mvp] [--output roadmap|tasks|detailed]

Arguments

• prd-file|feature-description – Path to PRD file or direct feature description
• --persona – Force specific expert persona (architect, frontend, backend, security, devops, etc.)
• --strategy – Workflow strategy (systematic, agile, mvp)
• --output – Output format (roadmap, tasks, detailed)
• --estimate – Include time and complexity estimates
• --dependencies – Map external dependencies and integrations
• --risks – Include risk assessment and mitigation strategies
• --parallel – Identify parallelizable work streams
• --milestones – Create milestone-based project phases

MCP Integration Flags

• --c7 / --context7 – Enable Context7 for framework patterns and best practices
• --sequential – Enable Sequential thinking for complex multi-step analysis
• --magic – Enable Magic for UI component workflow planning
• --all-mcp – Enable all MCP servers for comprehensive workflow generation

Workflow Strategies

Systematic Strategy (Default)

1. Requirements Analysis – Deep dive into PRD structure and acceptance criteria
2. Architecture Planning – System design and component architecture
3. Dependency Mapping – Identify all internal and external dependencies
4. Implementation Phases – Sequential phases with clear deliverables
5. Testing Strategy – Comprehensive testing approach at each phase
6. Deployment Planning – Production rollout and monitoring strategy

Agile Strategy

1. Epic Breakdown – Convert PRD into user stories and epics
2. Sprint Planning – Organize work into iterative sprints
3. MVP Definition – Identify minimum viable product scope
4. Iterative Development – Plan for continuous delivery and feedback
5. Stakeholder Engagement – Regular review and adjustment cycles
6. Retrospective Planning – Built-in improvement and learning cycles

MVP Strategy

1. Core Feature Identification – Strip down to essential functionality
2. Rapid Prototyping – Focus on quick validation and feedback
3. Technical Debt Planning – Identify shortcuts and future improvements
4. Validation Metrics – Define success criteria and measurement
5. Scaling Roadmap – Plan for post-MVP feature expansion
6. User Feedback Integration – Structured approach to user input

Expert Persona Auto-Activation

Frontend Workflow (--persona frontend or auto-detected)

• UI/UX Analysis – Design system integration and component planning
• State Management – Data flow and state architecture
• Performance Optimization – Bundle optimization and lazy loading
• Accessibility Compliance – WCAG guidelines and inclusive design
• Browser Compatibility – Cross-browser testing strategy
• Mobile Responsiveness – Responsive design implementation plan

Backend Workflow (--persona backend or auto-detected)

• API Design – RESTful/GraphQL endpoint planning
• Database Schema – Data modeling and migration strategy
• Security Implementation – Authentication, authorization, and data protection
• Performance Scaling – Caching, optimization, and load handling
• Service Integration – Third-party APIs and microservices
• Monitoring & Logging – Observability and debugging infrastructure

Architecture Workflow (--persona architect or auto-detected)

• System Design – High-level architecture and service boundaries
• Technology Stack – Framework and tool selection rationale
• Scalability Planning – Growth considerations and bottleneck prevention
• Security Architecture – Comprehensive security strategy
• Integration Patterns – Service communication and data flow
• DevOps Strategy – CI/CD pipeline and infrastructure as code

Security Workflow (--persona security or auto-detected)

• Threat Modeling – Security risk assessment and attack vectors
• Data Protection – Encryption, privacy, and compliance requirements
• Authentication Strategy – User identity and access management
• Security Testing – Penetration testing and vulnerability assessment
• Compliance Validation – Regulatory requirements (GDPR, HIPAA, etc.)
• Incident Response – Security monitoring and breach protocols

DevOps Workflow (--persona devops or auto-detected)

• Infrastructure Planning – Cloud architecture and resource allocation
• CI/CD Pipeline – Automated testing, building, and deployment
• Environment Management – Development, staging, and production environments
• Monitoring Strategy – Application and infrastructure monitoring
• Backup & Recovery – Data protection and disaster recovery planning
• Performance Monitoring – APM tools and performance optimization

Output Formats

Roadmap Format (--output roadmap)

# Feature Implementation Roadmap
## Phase 1: Foundation (Week 1-2)
- [ ] Architecture design and technology selection
- [ ] Database schema design and setup
- [ ] Basic project structure and CI/CD pipeline

## Phase 2: Core Implementation (Week 3-6)
- [ ] API development and authentication
- [ ] Frontend components and user interface
- [ ] Integration testing and security validation

## Phase 3: Enhancement & Launch (Week 7-8)
- [ ] Performance optimization and load testing
- [ ] User acceptance testing and bug fixes
- [ ] Production deployment and monitoring setup

Tasks Format (--output tasks)

# Implementation Tasks
## Epic: User Authentication System
### Story: User Registration
- [ ] Design registration form UI components
- [ ] Implement backend registration API
- [ ] Add email verification workflow
- [ ] Create user onboarding flow

### Story: User Login
- [ ] Design login interface
- [ ] Implement JWT authentication
- [ ] Add password reset functionality
- [ ] Set up session management

Detailed Format (--output detailed)

# Detailed Implementation Workflow
## Task: Implement User Registration API
**Persona**: Backend Developer
**Estimated Time**: 8 hours
**Dependencies**: Database schema, authentication service
**MCP Context**: Express.js patterns, security best practices

### Implementation Steps:
1. **Setup API endpoint** (1 hour)
   - Create POST /api/register route
   - Add input validation middleware

2. **Database integration** (2 hours)
   - Implement user model
   - Add password hashing

3. **Security measures** (3 hours)
   - Rate limiting implementation
   - Input sanitization
   - SQL injection prevention

4. **Testing** (2 hours)
   - Unit tests for registration logic
   - Integration tests for API endpoint

### Acceptance Criteria:
- [ ] User can register with email and password
- [ ] Passwords are properly hashed
- [ ] Email validation is enforced
- [ ] Rate limiting prevents abuse

Advanced Features

Dependency Analysis

• Internal Dependencies – Identify coupling between components and features
• External Dependencies – Map third-party services and APIs
• Technical Dependencies – Framework versions, database requirements
• Team Dependencies – Cross-team coordination requirements
• Infrastructure Dependencies – Cloud services, deployment requirements

Risk Assessment & Mitigation

• Technical Risks – Complexity, performance, and scalability concerns
• Timeline Risks – Dependency bottlenecks and resource constraints
• Security Risks – Data protection and compliance vulnerabilities
• Business Risks – Market changes and requirement evolution
• Mitigation Strategies – Fallback plans and alternative approaches

Parallel Work Stream Identification

• Independent Components – Features that can be developed simultaneously
• Shared Dependencies – Common components requiring coordination
• Critical Path Analysis – Bottlenecks that block other work
• Resource Allocation – Team capacity and skill distribution
• Communication Protocols – Coordination between parallel streams

Integration with SuperClaude Ecosystem

TodoWrite Integration

• Automatically creates session tasks for immediate next steps
• Provides progress tracking throughout workflow execution
• Links workflow phases to actionable development tasks

Task Command Integration

• Converts workflow into hierarchical project tasks (/sc:task)
• Enables cross-session persistence and progress tracking
• Supports complex orchestration with /sc:spawn

Implementation Command Integration

• Seamlessly connects to /sc:implement for feature development
• Provides context-aware implementation guidance
• Auto-activates appropriate personas for each workflow phase

Analysis Command Integration

• Leverages /sc:analyze for codebase assessment
• Integrates existing code patterns into workflow planning
• Identifies refactoring opportunities and technical debt

Usage Examples

Generate Workflow from PRD File

/sc:workflow docs/feature-100-prd.md --strategy systematic --c7 --sequential --estimate

Create Frontend-Focused Workflow

/sc:workflow "User dashboard with real-time analytics" --persona frontend --magic --output detailed

MVP Planning with Risk Assessment

/sc:workflow user-authentication-system --strategy mvp --risks --parallel --milestones

Backend API Workflow with Dependencies

/sc:workflow payment-processing-api --persona backend --dependencies --c7 --output tasks

Full-Stack Feature Workflow

/sc:workflow social-media-integration --all-mcp --sequential --parallel --estimate --output roadmap

Quality Gates and Validation

Workflow Completeness Check

• Requirements Coverage – Ensure all PRD requirements are addressed
• Acceptance Criteria – Validate testable success criteria
• Technical Feasibility – Assess implementation complexity and risks
• Resource Alignment – Match workflow to team capabilities and timeline

Best Practices Validation

• Architecture Patterns – Ensure adherence to established patterns
• Security Standards – Validate security considerations at each phase
• Performance Requirements – Include performance targets and monitoring
• Maintainability – Plan for long-term code maintenance and updates

Stakeholder Alignment

• Business Requirements – Ensure business value is clearly defined
• Technical Requirements – Validate technical specifications and constraints
• Timeline Expectations – Realistic estimation and milestone planning
• Success Metrics – Define measurable outcomes and KPIs

Performance Optimization

Workflow Generation Speed

• PRD Parsing – Efficient document analysis and requirement extraction
• Pattern Recognition – Rapid identification of common implementation patterns
• Template Application – Reusable workflow templates for common scenarios
• Incremental Generation – Progressive workflow refinement and optimization

Context Management

• Memory Efficiency – Optimal context usage for large PRDs
• Caching Strategy – Reuse analysis results across similar workflows
• Progressive Loading – Load workflow details on-demand
• Compression – Efficient storage and retrieval of workflow data

Success Metrics

Workflow Quality

• Implementation Success Rate – >90% successful feature completion following workflows
• Timeline Accuracy – <20% variance from estimated timelines
• Requirement Coverage – 100% PRD requirement mapping to workflow tasks
• Stakeholder Satisfaction – >85% satisfaction with workflow clarity and completeness

Performance Targets

• Workflow Generation – <30 seconds for standard PRDs
• Dependency Analysis – <60 seconds for complex systems
• Risk Assessment – <45 seconds for comprehensive evaluation
• Context Integration – <10 seconds for MCP server coordination

Claude Code Integration

• Multi-Tool Orchestration – Coordinates Read, Write, Edit, Glob, Grep for comprehensive analysis
• Progressive Task Creation – Uses TodoWrite for immediate next steps and Task for long-term planning
• MCP Server Coordination – Intelligent routing to Context7, Sequential, and Magic based on workflow needs
• Cross-Command Integration – Seamless handoff to implement, analyze, design, and other SuperClaude commands
• Evidence-Based Planning – Maintains audit trail of decisions and rationale throughout workflow generation