Intelligent web development framework with 22 specialized commands, 5 expert agents, 11 AI personas, and complete orchestration system for React, Next.js, Vue, and more
- version
- 2.1.1
- GitHub stars
- 37
Install
/plugin install wd@wd-marketplaceRun it inside Claude Code after adding the marketplace with /plugin marketplace add Para-FR/wd-framework.
Contents
Discovered from sourceCommands 22
/wd:analyze - Comprehensive Analysis
Purpose
Execute comprehensive code analysis across quality, security, performance, and architecture domains with intelligent persona activation and MCP integration.
Usage
/wd:analyze [target] [@<path>] [!<command>] [--<flags>]
Arguments
[target]- Files, directories, or project to analyze@<path>- Specific path or file pattern!<command>- Run command before analysis--focus quality|security|performance|architecture- Analysis focus area--depth quick|deep|comprehensive- Analysis depth--format text|json|report|markdown- Output format--wave-mode auto|force|off- Wave orchestration control--delegate files|folders|auto- Sub-agent delegation strategy--sharding auto|full|selective|index- Document loading strategy--facilitation- Enable guided discovery mode
Auto-Activation Patterns
Personas
- Analyzer: Root cause specialist (primary)
- Architect: System design and structure
- Security: Vulnerability assessment
- Performance: Bottleneck identification
MCP Servers
- Sequential: Primary for systematic analysis
- Context7: Best practices and patterns
- Magic: UI component analysis
Wave Orchestration
- Trigger: complexity ≥0.7 AND files >20 AND operation_types >2
- Strategy: Systematic methodical analysis
- Phases: Discovery → Analysis → Synthesis → Recommendations
Execution Workflow
-
Discovery Phase
- Glob for systematic file discovery
- Categorize by type and complexity
- Identify dependencies and relationships
-
Analysis Phase
- Apply domain-specific analysis techniques
- Grep for pattern-based analysis
- Read for deep code inspection
- Coordinate MCP servers for specialized insights
-
Synthesis Phase
- Aggregate findings across domains
- Rate severity and priority
- Identify patterns and anti-patterns
-
Reporting Phase
- Generate comprehensive analysis report
- Create actionable recommendations
- Provide priority-ordered improvements
Examples
# Quick security analysis
/wd:analyze auth-module --focus security --depth quick
# Comprehensive system analysis with wave mode
/wd:analyze @src/ --depth comprehensive --wave-mode force
# Performance bottleneck analysis
/wd:analyze --focus performance --delegate auto
# Multi-domain analysis with custom format
/wd:analyze entire-project --format report --depth deep
Document Sharding
For large codebases (>50 files):
| Strategy | File Size | Approach |
|---|---|---|
| FULL_LOAD | <5KB | Load entirely |
| SELECTIVE_LOAD | 5-50KB | Load relevant sections |
| INDEX_GUIDED | >50KB | Index first, load on-demand |
Auto-Trigger
- File count >50: enable INDEX_GUIDED
--sharding auto: intelligent selection- ~90% token reduction vs. full load
Integration Features
- Quality Gates: Applies 8-step validation cycle
- Evidence-Based: All findings backed by code references
- Actionable: Clear next steps with effort estimates
- Contextual: Adapts to project type and technology stack
- Sharding: Efficient large codebase handling
Output Structure
# Analysis Report: [Target]
## Executive Summary
- Total files analyzed: X
- Findings by severity: Critical (X), High (X), Medium (X), Low (X)
- Top 3 priorities with effort estimates
## Domain Analysis
### Quality
- Code quality metrics
- Maintainability index
- Technical debt estimate
### Security
- Vulnerability assessment
- Security hotspots
- Compliance status
### Performance
- Bottleneck identification
- Resource usage analysis
- Optimization opportunities
### Architecture
- Structure analysis
- Dependency review
- Design patterns
## Recommendations
1. [Priority 1]: Description with implementation steps
2. [Priority 2]: Description with implementation steps
...
Related Commands
/wd:improve- Apply recommended improvements/wd:review- Comprehensive code review/wd:troubleshoot- Debug specific issues/wd:estimate- Estimate implementation effort
/wd:benchmark - Performance Testing & Optimization
Purpose
Performance testing and optimization with visual reports and actionable insights.
Usage
/wd:benchmark [target] [--metrics performance|accessibility|seo|all] [--compare <baseline>] [--export <path>]
Auto-Persona Activation
- Performance: Optimization specialist and metrics analysis
- QA: Testing validation and quality assurance
MCP Integration
- Playwright: Performance metrics collection and browser automation
- Sequential: Systematic analysis and benchmark interpretation
Arguments
[target]- URL, file, or component to benchmark--metrics- Specific metrics to collectperformance: Load times, Core Web Vitals, resource usageaccessibility: WCAG compliance, screen reader compatibilityseo: Search engine optimization metricsall: Comprehensive metric collection
--compare <baseline>- Compare against baseline measurements--export <path>- Save detailed results to file
Performance Metrics
Core Web Vitals
- LCP (Largest Contentful Paint): Loading performance
- FID (First Input Delay): Interactivity responsiveness
- CLS (Cumulative Layout Shift): Visual stability
- FCP (First Contentful Paint): Initial render time
- TTI (Time to Interactive): Full interactivity timing
Resource Metrics
- Bundle Size: JavaScript, CSS, and asset sizes
- Network Usage: Request count, data transfer, caching efficiency
- Memory Usage: Heap size, memory leaks, garbage collection
- CPU Usage: Main thread blocking, script execution time
User Experience Metrics
- Load Time: Full page load on 3G/4G/WiFi
- Render Performance: Frame rate, paint times
- Interaction Response: Click, scroll, input responsiveness
- Error Rates: JavaScript errors, failed requests
Accessibility Metrics
- WCAG Compliance: AA/AAA standard validation
- Color Contrast: Text readability assessment
- Keyboard Navigation: Tab order and accessibility
- Screen Reader: Semantic markup and ARIA labels
- Focus Management: Visible focus indicators
SEO Metrics
- Page Speed Score: Google PageSpeed insights
- Mobile Friendliness: Responsive design validation
- Meta Tags: Title, description, structured data
- Content Analysis: Headings, keywords, readability
- Technical SEO: Sitemap, robots.txt, crawlability
Benchmark Types
Single Page Analysis
- Complete performance audit of individual pages
- Detailed breakdown of loading phases
- Resource waterfall analysis
- Optimization recommendations
Comparative Analysis
- Before/after performance comparison
- A/B testing results analysis
- Framework performance comparison
- Device and browser performance variance
Load Testing
- Concurrent user simulation
- Server response under load
- Database performance impact
- CDN and caching effectiveness
Examples
# Comprehensive performance benchmark
/wd:benchmark https://myapp.com --metrics all --export ./performance-report.json
# Compare against baseline
/wd:benchmark src/components/Dashboard.tsx --metrics performance --compare ./baseline.json
# Accessibility-focused audit
/wd:benchmark https://myapp.com/signup --metrics accessibility --export ./a11y-report.md
# SEO analysis
/wd:benchmark https://myapp.com --metrics seo
Report Features
Visual Reports
- Performance Charts: Timeline visualization of metrics
- Waterfall Diagrams: Resource loading sequence
- Heat Maps: User interaction patterns
- Trend Analysis: Performance over time
Actionable Insights
- Priority Recommendations: High-impact optimizations
- Code Splitting Opportunities: Bundle size reduction
- Image Optimization: Format and compression suggestions
- Caching Strategies: Browser and CDN optimization
Comparative Analysis
- Before/After Metrics: Improvement quantification
- Industry Benchmarks: Performance percentile ranking
- Competitor Analysis: Performance comparison
- Device Performance: Mobile vs desktop metrics
Integration Features
- CI/CD Integration: Automated performance monitoring
- Alert Thresholds: Performance regression detection
- Historical Tracking: Performance trend monitoring
- Team Dashboards: Shared performance insights
Output Formats
- JSON: Machine-readable metrics data
- HTML: Interactive visual reports
- PDF: Executive summary reports
- CSV: Raw data for analysis
- Markdown: Documentation-friendly format
/wd:brainstorm - Structured Idea Generation
Purpose
Structured idea generation and solution exploration with systematic analysis.
Usage
/wd:brainstorm [topic] [--format json|markdown|mindmap] [--depth shallow|deep|comprehensive] [--export <path>]
Auto-Persona Activation
- Mentor: Educational guidance and knowledge transfer
- Architect: Systems thinking and scalable solutions
- Analyzer: Evidence-based investigation and pattern recognition
MCP Integration
- Sequential: Structured thinking and systematic ideation
- Context7: Research patterns and industry best practices
Wave-Enabled
Multi-stage orchestration for complex brainstorming sessions with compound intelligence.
Arguments
[topic]- Subject or problem to brainstorm about--format- Output format (json, markdown, mindmap)--depth- Analysis depth levelshallow: Quick ideas and initial conceptsdeep: Detailed analysis with pros/conscomprehensive: Full analysis with implementation roadmap
--export <path>- Save results to specified file
Examples
# Quick brainstorm on user experience
/wd:brainstorm "improving user onboarding" --depth shallow
# Comprehensive analysis with export
/wd:brainstorm "microservices architecture" --depth comprehensive --export ./brainstorm-results.md
# Technical solution exploration
/wd:brainstorm "performance optimization strategies" --format json --depth deep
Output Structure
- Problem Analysis: Current situation and challenges
- Idea Categories: Organized solution concepts
- Implementation Approaches: Practical next steps
- Risk Assessment: Potential challenges and mitigation
- Priority Matrix: Ranked recommendations with effort/impact analysis
/wd:build - Project Building
Purpose
Build, compile, and package projects with comprehensive error handling, optimization, and framework-specific intelligence.
Usage
/wd:build [target] [--type <type>] [--<flags>]
Arguments
[target]- Project or specific component to build (optional, defaults to current project)--type dev|prod|test|staging- Build type and environment--clean- Clean build artifacts before building--optimize- Enable aggressive build optimizations--verbose- Enable detailed build output--watch- Enable watch mode for development--analyze- Analyze bundle size and dependencies--no-cache- Disable build cache
Auto-Activation Patterns
Personas
-
Frontend: UI builds with asset optimization
- Triggers: React, Vue, Angular, Svelte projects
- Focus: Bundle optimization, code splitting, asset handling
-
Backend: API and service compilation
- Triggers: Node.js, Python, Go, Rust projects
- Focus: Dependency management, environment configs
-
Architect: Complex multi-service builds
- Triggers: Monorepos, microservices, multi-target builds
- Focus: Build orchestration, dependency resolution
-
DevOps: Production builds and deployment prep
- Triggers:
--type prod, CI/CD context - Focus: Optimization, security, containerization
- Triggers:
MCP Servers
- Magic: UI build optimization and asset processing
- Context7: Framework-specific build patterns and best practices
- Sequential: Complex multi-step build orchestration
Framework Detection
Automatic Detection
- JavaScript/TypeScript: package.json scripts detection
- Python: setup.py, pyproject.toml, requirements.txt
- Rust: Cargo.toml
- Go: go.mod
- Java: pom.xml, build.gradle
- C/C++: CMakeLists.txt, Makefile
Build Tool Recognition
- npm, yarn, pnpm, bun
- webpack, vite, rollup, esbuild
- cargo, go build
- maven, gradle
- make, cmake
Execution Workflow
-
Discovery Phase
- Analyze project structure and detect framework
- Identify build configuration files
- Determine build tool and commands
- Check dependencies and environment
-
Pre-Build Validation
- Verify all dependencies are installed
- Check environment variables
- Validate build configuration
- Run type checking (TypeScript, etc.)
-
Build Execution
- Clean artifacts if requested
- Execute appropriate build commands
- Monitor build process and capture output
- Handle errors with diagnostic information
-
Post-Build Analysis
- Analyze build output and artifacts
- Generate bundle size report (if applicable)
- Check for common issues
- Provide optimization recommendations
-
Quality Gates (Production Builds)
- Run tests if available
- Check bundle size budgets
- Verify no security vulnerabilities
- Validate environment configurations
Examples
# Development build with watch mode
/wd:build --type dev --watch
# Production build with optimization
/wd:build --type prod --optimize --clean
# Analyze bundle size
/wd:build --type prod --analyze
# Clean build without cache
/wd:build --clean --no-cache
# Build specific target (monorepo)
/wd:build @workspace/frontend --type prod
# Verbose build for debugging
/wd:build --type dev --verbose
Build Optimizations
Frontend Optimizations
- Code Splitting: Automatic route-based splitting
- Tree Shaking: Remove unused code
- Minification: JavaScript and CSS compression
- Image Optimization: Compress and convert images
- Asset Inlining: Inline small assets
- Lazy Loading: Defer non-critical resources
Backend Optimizations
- Dependency Pruning: Remove dev dependencies
- Binary Optimization: Reduce binary size
- Dead Code Elimination: Remove unused code paths
- Compilation Flags: Optimize for target platform
Error Handling
Common Build Errors
-
Missing Dependencies
- Diagnosis: Parse error messages
- Solution: Auto-suggest installation commands
-
Type Errors
- Diagnosis: Identify type mismatches
- Solution: Provide fix suggestions
-
Configuration Issues
- Diagnosis: Validate config files
- Solution: Suggest correct configuration
-
Memory Issues
- Diagnosis: Detect OOM errors
- Solution: Recommend memory allocation adjustments
Recovery Strategies
- Automatic retry with cache clearing
- Incremental build fallback
- Dependency reinstallation suggestions
- Configuration validation and fixing
Output Structure
# Build Report: [Project Name]
## Build Configuration
- Type: [dev|prod|test]
- Framework: [framework-name]
- Build Tool: [tool-name]
- Duration: [time]
## Build Steps
✅ Dependency check
✅ Type checking
✅ Compilation
✅ Bundling
✅ Optimization
## Build Artifacts
- Output directory: `./dist`
- Main bundle: `app.js` (245 KB)
- Styles: `app.css` (18 KB)
- Assets: 12 files (1.2 MB)
## Performance Metrics
- Build time: 12.5s
- Bundle size: 245 KB (gzipped: 78 KB)
- Chunks: 8
- Tree shaking: 32% reduction
## Optimization Recommendations
1. Consider code splitting for route `/dashboard`
2. Image `hero.png` can be optimized (save 120 KB)
3. Bundle size exceeds recommended 250 KB threshold
## Next Steps
- Run tests: `/wd:test`
- Deploy build: `/wd:deploy`
- Analyze performance: `/wd:benchmark`
Production Build Checklist
- Environment variables configured
- Dependencies up to date
- Security vulnerabilities checked
- Tests passing
- Bundle size within budget
- Source maps generated
- Assets optimized
- Build reproducible
- Documentation updated
Related Commands
/wd:implement- Implement new features before building/wd:test- Run test suite/wd:improve --perf- Optimize build performance/wd:analyze- Analyze build configuration/wd:finalize- Complete build + test + deploy workflow
/wd:cleanup - Code and Project Cleanup
Purpose
Systematically clean up code, remove dead code, optimize imports, and improve project structure.
Usage
/wd:cleanup [target] [--type code|imports|files|all] [--safe|--aggressive]
Arguments
target- Files, directories, or entire project to clean--type- Cleanup type (code, imports, files, all)--safe- Conservative cleanup (default)--aggressive- More thorough cleanup with higher risk--dry-run- Preview changes without applying them
Execution
- Analyze target for cleanup opportunities
- Identify dead code, unused imports, and redundant files
- Create cleanup plan with risk assessment
- Execute cleanup operations with appropriate safety measures
- Validate changes and report cleanup results
Claude Code Integration
- Uses Glob for systematic file discovery
- Leverages Grep for dead code detection
- Applies MultiEdit for batch cleanup operations
- Maintains backup and rollback capabilities
/wd:design - System and Component Design
Purpose
Design system architecture, APIs, component interfaces, and technical specifications.
Usage
/wd:design [target] [--type architecture|api|component|database] [--format diagram|spec|code]
Arguments
target- System, component, or feature to design--type- Design type (architecture, api, component, database)--format- Output format (diagram, spec, code)--iterative- Enable iterative design refinement
Execution
- Analyze requirements and design constraints
- Create initial design concepts and alternatives
- Develop detailed design specifications
- Validate design against requirements and best practices
- Generate design documentation and implementation guides
Claude Code Integration
- Uses Read for requirement analysis
- Leverages Write for design documentation
- Applies TodoWrite for design task tracking
- Maintains consistency with architectural patterns
/wd:document - Focused Documentation
Purpose
Generate precise, focused documentation for specific components, functions, or features.
Usage
/wd:document [target] [--type inline|external|api|guide] [--style brief|detailed]
Arguments
target- Specific file, function, or component to document--type- Documentation type (inline, external, api, guide)--style- Documentation style (brief, detailed)--template- Use specific documentation template
Execution
- Analyze target component and extract key information
- Identify documentation requirements and audience
- Generate appropriate documentation based on type and style
- Apply consistent formatting and structure
- Integrate with existing documentation ecosystem
Claude Code Integration
- Uses Read for deep component analysis
- Leverages Edit for inline documentation updates
- Applies Write for external documentation creation
- Maintains documentation standards and conventions
/wd:estimate - Development Estimation
Purpose
Generate accurate development estimates for tasks, features, or projects based on complexity analysis.
Usage
/wd:estimate [target] [--type time|effort|complexity|cost] [--unit hours|days|weeks]
Arguments
target- Task, feature, or project to estimate--type- Estimation type (time, effort, complexity, cost)--unit- Time unit for estimates (hours, days, weeks)--breakdown- Provide detailed breakdown of estimates
Execution
- Analyze scope and requirements of target
- Identify complexity factors and dependencies
- Apply estimation methodologies and historical data
- Generate estimates with confidence intervals
- Present detailed breakdown with risk factors
Claude Code Integration
- Uses Read for requirement analysis
- Leverages Glob for codebase complexity assessment
- Applies Grep for pattern-based estimation
- Maintains structured estimation documentation
/wd:explain - Code and Concept Explanation
Purpose
Deliver clear, comprehensive explanations of code functionality, concepts, or system behavior.
Usage
/wd:explain [target] [--level basic|intermediate|advanced] [--format text|diagram|examples]
Arguments
target- Code file, function, concept, or system to explain--level- Explanation complexity (basic, intermediate, advanced)--format- Output format (text, diagram, examples)--context- Additional context for explanation
Execution
- Analyze target code or concept thoroughly
- Identify key components and relationships
- Structure explanation based on complexity level
- Provide relevant examples and use cases
- Present clear, accessible explanation with proper formatting
Claude Code Integration
- Uses Read for comprehensive code analysis
- Leverages Grep for pattern identification
- Applies Bash for runtime behavior analysis
- Maintains clear, educational communication style
/wd:finalize - Complete Project Finalization
Purpose
Complete project finalization with quality gates and git workflow automation.
Usage
/wd:finalize [commit-message] [--skip-docs] [--skip-lint] [--skip-types] [--skip-build] [--dry-run] [--no-push]
Workflow Pipeline
- Update documentation (.md files) with latest changes
- Detect Next.js version from package.json
- If Next.js < 16: Run
bun lintfor code quality validation - Run
bun typefor TypeScript type checking - Run
bun buildfor compilation verification - Generate structured commit message if not provided
- Git add, commit, and push if all gates pass
Note: Next.js 16+ removed
next lint. The command auto-detects the version and skips linting for Next.js 16+.
Auto-Persona Activation
- DevOps: Infrastructure and deployment automation
- QA: Quality assurance and testing validation
- Scribe: Professional commit message generation
MCP Integration
- Sequential: Workflow coordination and systematic validation
- Context7: Best practices and commit message patterns
Arguments
[commit-message]- Custom commit message (optional)--skip-docs- Skip documentation updates--skip-lint- Skip linting validation (only applies to Next.js < 16)--skip-types- Skip TypeScript type checking--skip-build- Skip build verification--dry-run- Show what would be done without executing--no-push- Commit locally but don't push to remote
Examples
# Full workflow with custom message
/wd:finalize "feat: add user authentication system"
# Skip some steps
/wd:finalize --skip-docs --skip-build
# Dry run to see what would happen
/wd:finalize --dry-run
# Commit locally only
/wd:finalize "fix: resolve login bug" --no-push
Perfect for automating the repetitive "document + lint + build + commit + push" workflow you mentioned!
/wd:git - Git Operations
Purpose
Execute Git operations with intelligent commit messages, branch management, and workflow optimization.
Usage
/wd:git [operation] [args] [--smart-commit] [--branch-strategy]
Arguments
operation- Git operation (add, commit, push, pull, merge, branch, status)args- Operation-specific arguments--smart-commit- Generate intelligent commit messages--branch-strategy- Apply branch naming conventions--interactive- Interactive mode for complex operations
Execution
- Analyze current Git state and repository context
- Execute requested Git operations with validation
- Apply intelligent commit message generation
- Handle merge conflicts and branch management
- Provide clear feedback and next steps
Claude Code Integration
- Uses Bash for Git command execution
- Leverages Read for repository analysis
- Applies TodoWrite for operation tracking
- Maintains Git best practices and conventions
/wd:implement - Feature Implementation
Purpose
Implement features, components, and code functionality with intelligent expert activation, comprehensive development support, and best practices enforcement.
Usage
/wd:implement [feature-description] [--type <type>] [--framework <name>] [--<flags>]
Arguments
[feature-description]- Clear description of what to implement--type component|api|service|feature|module- Implementation type--framework react|vue|angular|express|fastapi|etc- Target framework--safe- Use conservative implementation approach--iterative- Enable iterative development with validation--with-tests- Include test implementation--documentation- Generate documentation alongside code--agent <agent-name>- Manually activate specific agent--agents <agent-list>- Activate multiple coordinated agents--track quick|standard|enterprise- Development track selection--skill-level beginner|intermediate|expert- Output verbosity--yolo- Automated execution mode--story <file>- Use story file as source of truth
Auto-Activation Patterns
Personas (Context-Dependent)
-
Frontend: UI components, React/Vue/Angular development
- Keywords: component, UI, React, Vue, responsive, accessibility
- Files:
*.jsx,*.tsx,*.vue,*.css
-
Backend: APIs, services, database integration
- Keywords: API, database, server, endpoint, authentication
- Files:
*.js,*.ts,*.py,*.go,controllers/*,models/*
-
Security: Authentication, authorization, data protection
- Keywords: auth, security, encryption, validation
- Auto-activates for sensitive operations
-
Architect: System design and module structure
- Complex features requiring architectural decisions
- Multi-component implementations
MCP Servers
- Magic: Primary for UI component generation and design systems
- Context7: Framework documentation and implementation patterns
- Sequential: Complex business logic and multi-step workflows
Agent Coordination
- Single Domain: Domain-specific agent (frontend, backend, etc.)
- Multi-Domain: Hierarchical coordination with multiple specialists
- Testing: Automatic test-agent activation with
--with-tests - Documentation: Automatic docs-agent activation with
--documentation
Execution Workflow
-
Requirements Analysis
- Parse feature description and detect technology context
- Identify required components and dependencies
- Determine implementation complexity
-
Persona & Agent Activation
- Auto-activate relevant personas based on context
- Route to specialized agents when beneficial
- Coordinate MCP servers for enhanced capabilities
-
Implementation Phase
- Generate code with framework best practices
- Apply security and quality validation
- Follow project conventions and patterns
- Use appropriate design patterns
-
Testing & Validation
- Generate tests if requested
- Validate against requirements
- Check for common pitfalls and vulnerabilities
-
Documentation & Next Steps
- Document implementation decisions
- Provide usage examples
- Suggest testing and integration steps
BMAD Protocol
Story File Discovery
- Check for
.story.mdorstory.mdin project root - If found, use as single source of truth
- Execute tasks in story-defined sequence
ADR Consultation
- Scan
docs/decisions/or.adr/directory - Load relevant ADRs based on implementation domain
- Reference decisions in code comments
Track-Aware Execution
| Track | Phases |
|---|---|
| quick | Implement only |
| standard | Analyze → Plan → Implement → Validate |
| enterprise | + ADR creation + Adversarial review |
Skill Level Output
| Level | Behavior |
|---|---|
| beginner | Detailed explanations, extensive comments |
| intermediate | Balanced context (default) |
| expert | Code-first, minimal commentary |
Examples
# Frontend component with tests
/wd:implement LoginComponent --type component --framework react --with-tests
# Backend API with documentation
/wd:implement user-authentication-system --type feature --documentation
# Multi-agent full-stack feature
/wd:implement user-dashboard --agents frontend,backend,test,docs
# Safe iterative implementation
/wd:implement payment-processing-service --type service --safe --iterative
# Explicit agent selection
/wd:implement REST-API-users --type api --agent gd-backend-agent
Integration Features
Framework Detection
- Automatically detects project framework and conventions
- Adapts code style to existing patterns
- Uses project-specific dependencies
Security-First
- Security persona auto-activates for sensitive operations
- Input validation by default
- OWASP compliance checks
Quality Assurance
- Code quality validation
- Performance considerations
- Accessibility compliance (for UI components)
Testing Integration
- Unit test generation
- Integration test suggestions
- E2E test strategies with Playwright agent
Output Structure
# Implementation: [Feature Name]
## Summary
- Type: [component|api|service|feature]
- Framework: [framework-name]
- Complexity: [low|medium|high]
- Estimated time: [time estimate]
## Files Created/Modified
- `path/to/file1.ts` - Description
- `path/to/file2.ts` - Description
## Implementation Details
[Code with explanations]
## Security Considerations
- [Security measure 1]
- [Security measure 2]
## Testing
- Unit tests: [location]
- Integration tests: [strategy]
- E2E tests: [recommendations]
## Next Steps
1. [Step 1]
2. [Step 2]
3. [Step 3]
## Documentation
[Usage examples and API documentation]
Best Practices
Code Quality
- Follow SOLID principles
- Use appropriate design patterns
- Maintain DRY principle
- Ensure proper error handling
Performance
- Optimize critical paths
- Consider scalability
- Monitor resource usage
- Implement caching strategies
Security
- Input validation
- Authentication/Authorization
- Secure data handling
- OWASP compliance
Testing
- Comprehensive test coverage
- Edge case handling
- Integration testing
- Performance testing
Related Commands
/wd:build- Build and compile project/wd:test- Run test suite/wd:improve- Enhance existing implementation/wd:review- Code review before merge/wd:document- Generate documentation
/wd:improve - Code Improvement
Purpose
Apply systematic improvements to code quality, performance, maintainability, and best practices.
Usage
/wd:improve [target] [--type quality|performance|maintainability|style] [--safe]
Arguments
target- Files, directories, or project to improve--type- Improvement type (quality, performance, maintainability, style)--safe- Apply only safe, low-risk improvements--preview- Show improvements without applying them
Execution
- Analyze code for improvement opportunities
- Identify specific improvement patterns and techniques
- Create improvement plan with risk assessment
- Apply improvements with appropriate validation
- Verify improvements and report changes
Claude Code Integration
- Uses Read for comprehensive code analysis
- Leverages MultiEdit for batch improvements
- Applies TodoWrite for improvement tracking
- Maintains safety and validation mechanisms
/wd:index - Project Documentation
Purpose
Create and maintain comprehensive project documentation, indexes, and knowledge bases.
Usage
/wd:index [target] [--type docs|api|structure|readme] [--format md|json|yaml]
Arguments
target- Project directory or specific component to document--type- Documentation type (docs, api, structure, readme)--format- Output format (md, json, yaml)--update- Update existing documentation
Execution
- Analyze project structure and identify key components
- Extract documentation from code comments and README files
- Generate comprehensive documentation based on type
- Create navigation structure and cross-references
- Output formatted documentation with proper organization
Claude Code Integration
- Uses Glob for systematic file discovery
- Leverages Grep for extracting documentation patterns
- Applies Write for creating structured documentation
- Maintains consistency with project conventions
/wd:load - Project Context Loading
Purpose
Load and analyze project context, configurations, dependencies, and environment setup.
Usage
/wd:load [target] [--type project|config|deps|env] [--cache]
Arguments
target- Project directory or specific configuration to load--type- Loading type (project, config, deps, env)--cache- Cache loaded context for faster subsequent access--refresh- Force refresh of cached context
Execution
- Discover and analyze project structure and configuration files
- Load dependencies, environment variables, and settings
- Parse and validate configuration consistency
- Create comprehensive project context map
- Cache context for efficient future access
Claude Code Integration
- Uses Glob for comprehensive project discovery
- Leverages Read for configuration analysis
- Applies Bash for environment validation
- Maintains efficient context caching mechanisms
/wd:migrate - Code Migration Assistant
Purpose
Code migration between frameworks and technologies with systematic planning and validation.
Usage
/wd:migrate [source-framework] [target-framework] [--strategy incremental|complete|hybrid] [--validate] [--backup]
Auto-Persona Activation
- Architect: Migration planning and system design
- Frontend: UI framework migrations (React, Vue, Angular)
- Backend: Server framework migrations (context-dependent)
MCP Integration
- Context7: Framework patterns and migration best practices
- Sequential: Migration planning and systematic execution
- Magic: UI component migration and modern framework patterns
Wave-Enabled
Multi-stage orchestration for complex migration projects with validation checkpoints.
Arguments
[source-framework]- Current framework or technology[target-framework]- Target framework or technology--strategy- Migration approachincremental: Gradual migration with coexistencecomplete: Full migration in single phasehybrid: Mixed approach based on component complexity
--validate- Enable validation at each step--backup- Create backup before migration
Supported Migration Paths
Frontend Frameworks
- React ↔ Vue: Component and state management migration
- Angular → React/Vue: Enterprise application modernization
- jQuery → Modern Framework: Legacy JavaScript modernization
- Class Components → Hooks: React modernization
Backend Frameworks
- Express → Fastify/Hapi: Node.js framework migration
- Django → FastAPI: Python framework modernization
- Spring Boot → Micronaut: Java microservice migration
Build Tools & Package Managers
- Webpack → Vite: Build tool modernization
- npm → pnpm/bun: Package manager migration
- Babel → SWC/esbuild: Transpilation tool upgrade
Database & ORM
- MySQL → PostgreSQL: Database engine migration
- Mongoose → Prisma: MongoDB ORM modernization
- Sequelize → TypeORM: SQL ORM migration
Migration Process
1. Analysis Phase
- Dependency mapping and compatibility assessment
- Breaking changes identification
- Custom code patterns analysis
- Test coverage evaluation
2. Planning Phase
- Migration strategy selection and timeline
- Risk assessment and mitigation plans
- Rollback procedures and safety measures
- Team training and knowledge transfer
3. Execution Phase
- Systematic code transformation
- Configuration and build tool updates
- Dependency updates and conflict resolution
- Testing and validation at each step
4. Validation Phase
- Functional testing and regression validation
- Performance comparison and optimization
- Security audit and compliance check
- Documentation updates and team handoff
Examples
# React to Vue migration with incremental strategy
/wd:migrate React Vue --strategy incremental --validate --backup
# Express to Fastify with complete migration
/wd:migrate Express Fastify --strategy complete --validate
# jQuery to React modernization
/wd:migrate jQuery React --strategy hybrid --backup
# Database migration with validation
/wd:migrate MySQL PostgreSQL --validate
Safety Features
- Automatic Backup: Code backup before major changes
- Rollback Support: Easy reversal of migration steps
- Validation Checkpoints: Quality gates at each phase
- Parallel Development: Maintain old system during migration
- Incremental Testing: Continuous validation throughout process
Output Deliverables
- Migration Plan: Detailed roadmap with timelines
- Compatibility Report: Breaking changes and solutions
- Code Transformation: Updated codebase with modern patterns
- Testing Suite: Comprehensive validation tests
- Documentation: Updated guides and API references
- Performance Report: Before/after comparison metrics
/wd:review - Comprehensive Code Review
Purpose
Comprehensive code and system review with actionable insights and quality metrics.
Usage
/wd:review [target] [--focus security|performance|quality|architecture] [--format report|checklist|metrics] [--export <path>]
Auto-Persona Activation
- QA: Quality assurance and testing standards
- Security: Vulnerability assessment and compliance
- Performance: Optimization and bottleneck analysis
- Analyzer: Root cause analysis and systematic investigation
MCP Integration
- Sequential: Systematic analysis and structured review
- Context7: Best practices and quality standards
- Playwright: E2E validation and user workflow testing
Wave-Enabled
Multi-agent parallel analysis for comprehensive system review.
Arguments
[target]- Files, directories, or components to review--focus- Specific review focus areasecurity: Security vulnerabilities and complianceperformance: Performance bottlenecks and optimizationquality: Code quality and maintainabilityarchitecture: System design and structure
--format- Output formatreport: Detailed analysis reportchecklist: Actionable checklist formatmetrics: Quantified quality metrics
--export <path>- Save review results to file
Review Categories
Security Review
- Vulnerability scanning and threat analysis
- Authentication and authorization validation
- Data protection and privacy compliance
- Secure coding practices assessment
Performance Review
- Code efficiency and optimization opportunities
- Resource usage analysis and bottleneck identification
- Scalability assessment and load handling
- Database query optimization
Quality Review
- Code complexity and maintainability metrics
- Technical debt identification and prioritization
- Testing coverage and quality assessment
- Documentation completeness and accuracy
Architecture Review
- System design patterns and best practices
- Component coupling and cohesion analysis
- Scalability and extensibility evaluation
- Integration patterns and API design
Examples
# Security-focused review
/wd:review src/auth/ --focus security --format report
# Performance analysis with metrics
/wd:review --focus performance --format metrics --export ./performance-review.json
# Comprehensive quality review
/wd:review src/ --focus quality --format checklist
# Full system architecture review
/wd:review --focus architecture --format report --export ./architecture-analysis.md
Output Includes
- Executive Summary: Key findings and recommendations
- Detailed Analysis: Issue-by-issue breakdown with context
- Priority Matrix: Issues ranked by severity and effort
- Actionable Recommendations: Specific steps for improvement
- Quality Metrics: Quantified assessment scores
- Follow-up Plan: Suggested review schedule and checkpoints
/wd:spawn - Task Orchestration
Purpose
Decompose complex requests into manageable subtasks and coordinate their execution.
Usage
/wd:spawn [task] [--sequential|--parallel] [--validate]
Arguments
task- Complex task or project to orchestrate--sequential- Execute tasks in dependency order (default)--parallel- Execute independent tasks concurrently--validate- Enable quality checkpoints between tasks
Execution
- Parse request and create hierarchical task breakdown
- Map dependencies between subtasks
- Choose optimal execution strategy (sequential/parallel)
- Execute subtasks with progress monitoring
- Integrate results and validate completion
Claude Code Integration
- Uses TodoWrite for task breakdown and tracking
- Leverages file operations for coordinated changes
- Applies efficient batching for related operations
- Maintains clear dependency management
/wd:task - Enhanced Task Management
Purpose
Execute complex tasks with intelligent workflow management, cross-session persistence, hierarchical task organization, and advanced orchestration capabilities.
Usage
/wd:task [action] [target] [--strategy systematic|agile|enterprise] [--persist] [--hierarchy] [--delegate]
Actions
create- Create new project-level task hierarchyexecute- Execute task with intelligent orchestrationstatus- View task status across sessionsanalytics- Task performance and analytics dashboardoptimize- Optimize task execution strategiesdelegate- Delegate tasks across multiple agentsvalidate- Validate task completion with evidence
Arguments
target- Task description, project scope, or existing task ID--strategy- Execution strategy (systematic, agile, enterprise)--persist- Enable cross-session task persistence--hierarchy- Create hierarchical task breakdown--delegate- Enable multi-agent task delegation--wave-mode- Enable wave-based execution--validate- Enforce quality gates and validation--mcp-routing- Enable intelligent MCP server routing
Execution Modes
Systematic Strategy
- Discovery Phase: Comprehensive project analysis and scope definition
- Planning Phase: Hierarchical task breakdown with dependency mapping
- Execution Phase: Sequential execution with validation gates
- Validation Phase: Evidence collection and quality assurance
- Optimization Phase: Performance analysis and improvement recommendations
Agile Strategy
- Sprint Planning: Priority-based task organization
- Iterative Execution: Short cycles with continuous feedback
- Adaptive Planning: Dynamic task adjustment based on outcomes
- Continuous Integration: Real-time validation and testing
- Retrospective Analysis: Learning and process improvement
Enterprise Strategy
- Stakeholder Analysis: Multi-domain impact assessment
- Resource Allocation: Optimal resource distribution across tasks
- Risk Management: Comprehensive risk assessment and mitigation
- Compliance Validation: Regulatory and policy compliance checks
- Governance Reporting: Detailed progress and compliance reporting
Advanced Features
Task Hierarchy Management
- Epic Level: Large-scale project objectives (weeks to months)
- Story Level: Feature-specific implementations (days to weeks)
- Task Level: Specific actionable items (hours to days)
- Subtask Level: Granular implementation steps (minutes to hours)
Intelligent Task Orchestration
- Dependency Resolution: Automatic dependency detection and sequencing
- Parallel Execution: Independent task parallelization
- Resource Optimization: Intelligent resource allocation and scheduling
- Context Sharing: Cross-task context and knowledge sharing
Cross-Session Persistence
- Task State Management: Persistent task states across sessions
- Context Continuity: Preserved context and progress tracking
- Historical Analytics: Task execution history and learning
- Recovery Mechanisms: Automatic recovery from interruptions
Session Frontmatter Tracking
Tasks maintain state across sessions via frontmatter:
task: implement-auth
current_step: 3
total_steps: 7
status: in_progress
context: ["auth_patterns", "security_requirements"]
last_checkpoint: 2024-01-07T10:30:00Z
YOLO Mode
When --yolo enabled:
- Auto-advance through non-critical steps
- Skip explanation generation
- Direct implementation path
- Security gates still enforced
Progressive Disclosure
- Step-by-step execution (no skipping)
- Checkpoint gates require confirmation
- Context accumulates across steps
- Story file authority maintained
Quality Gates and Validation
- Evidence Collection: Systematic evidence gathering during execution
- Validation Criteria: Customizable completion criteria
- Quality Metrics: Comprehensive quality assessment
- Compliance Checks: Automated compliance validation
Integration Points
Wave System Integration
- Wave Coordination: Multi-wave task execution strategies
- Context Accumulation: Progressive context building across waves
- Performance Monitoring: Real-time performance tracking and optimization
- Error Recovery: Graceful error handling and recovery mechanisms
MCP Server Coordination
- Context7: Framework patterns and library documentation
- Sequential: Complex analysis and multi-step reasoning
- Magic: UI component generation and design systems
- Playwright: End-to-end testing and performance validation
Persona Integration
- Architect: System design and architectural decisions
- Analyzer: Code analysis and quality assessment
- Project Manager: Resource allocation and progress tracking
- Domain Experts: Specialized expertise for specific task types
Performance Optimization
Execution Efficiency
- Batch Operations: Grouped execution for related tasks
- Parallel Processing: Independent task parallelization
- Context Caching: Reusable context and analysis results
- Resource Pooling: Shared resource utilization
Intelligence Features
- Predictive Planning: AI-driven task estimation and planning
- Adaptive Execution: Dynamic strategy adjustment based on progress
- Learning Systems: Continuous improvement from execution patterns
- Optimization Recommendations: Data-driven improvement suggestions
Usage Examples
Create Project-Level Task Hierarchy
/wd:task create "Implement user authentication system" --hierarchy --persist --strategy systematic
Execute with Multi-Agent Delegation
/wd:task execute AUTH-001 --delegate --wave-mode --validate
Analytics and Optimization
/wd:task analytics --project AUTH --optimization-recommendations
Cross-Session Task Management
/wd:task status --all-sessions --detailed-breakdown
Claude Code Integration
- TodoWrite Integration: Seamless session-level task coordination
- Wave System: Advanced multi-stage execution orchestration
- Hook System: Real-time task monitoring and optimization
- MCP Coordination: Intelligent server routing and resource utilization
- Performance Monitoring: Sub-100ms execution targets with comprehensive metrics
Success Criteria
- Task Completion Rate: >95% successful task completion
- Performance Targets: <100ms hook execution, <5s task creation
- Quality Metrics: >90% validation success rate
- Cross-Session Continuity: 100% task state preservation
- Intelligence Effectiveness: >80% accurate predictive planning
/wd:test - Testing and Quality Assurance
Purpose
Execute tests, generate comprehensive test reports, and maintain test coverage standards.
Usage
/wd:test [target] [--type unit|integration|e2e|all] [--coverage] [--watch]
Arguments
target- Specific tests, files, or entire test suite--type- Test type (unit, integration, e2e, all)--coverage- Generate coverage reports--watch- Run tests in watch mode--fix- Automatically fix failing tests when possible
Execution
- Discover and categorize available tests
- Execute tests with appropriate configuration
- Monitor test results and collect metrics
- Generate comprehensive test reports
- Provide recommendations for test improvements
Claude Code Integration
- Uses Bash for test execution and monitoring
- Leverages Glob for test discovery
- Applies TodoWrite for test result tracking
- Maintains structured test reporting and coverage analysis
/wd:troubleshoot - Issue Diagnosis and Resolution
Purpose
Systematically diagnose and resolve issues in code, builds, deployments, or system behavior.
Usage
/wd:troubleshoot [issue] [--type bug|build|performance|deployment] [--trace] [--fix]
Arguments
issue- Description of the problem or error message--type- Issue category (bug, build, performance, deployment)--trace- Enable detailed tracing and logging--fix- Automatically apply fixes when safe
Execution
- Analyze issue description and gather initial context
- Identify potential root causes and investigation paths
- Execute systematic debugging and diagnosis
- Propose and validate solution approaches
- Apply fixes and verify resolution
Claude Code Integration
- Uses Read for error log analysis
- Leverages Bash for runtime diagnostics
- Applies Grep for pattern-based issue detection
- Maintains structured troubleshooting documentation
/wd:workflow - Implementation Workflow Generator
Purpose
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.
Usage
/wd: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, story, adr)--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--track quick|standard|enterprise- Development track selection
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)
- Requirements Analysis - Deep dive into PRD structure and acceptance criteria
- Architecture Planning - System design and component architecture
- Dependency Mapping - Identify all internal and external dependencies
- Implementation Phases - Sequential phases with clear deliverables
- Testing Strategy - Comprehensive testing approach at each phase
- Deployment Planning - Production rollout and monitoring strategy
Agile Strategy
- Epic Breakdown - Convert PRD into user stories and epics
- Sprint Planning - Organize work into iterative sprints
- MVP Definition - Identify minimum viable product scope
- Iterative Development - Plan for continuous delivery and feedback
- Stakeholder Engagement - Regular review and adjustment cycles
- Retrospective Planning - Built-in improvement and learning cycles
MVP Strategy
- Core Feature Identification - Strip down to essential functionality
- Rapid Prototyping - Focus on quick validation and feedback
- Technical Debt Planning - Identify shortcuts and future improvements
- Validation Metrics - Define success criteria and measurement
- Scaling Roadmap - Plan for post-MVP feature expansion
- 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
Story Format (--output story)
# Story: User Authentication System
## Context
Implement secure user authentication with email/password and social login options.
## Tasks
1. [ ] Design authentication flow architecture
2. [ ] Implement user registration API
3. [ ] Create login/logout endpoints
4. [ ] Add password reset functionality
5. [ ] Integrate social login providers
6. [ ] Write comprehensive tests
## Acceptance Criteria
- [ ] Users can register with email/password
- [ ] OAuth2 integration working
- [ ] 95% test coverage achieved
## ADR References
- ADR-001: Authentication Strategy
- ADR-002: Password Hashing Algorithm
ADR Format (--output adr)
# ADR-XXX: [Decision Title]
## Context
[Why this decision is needed - background and constraints]
## Options Considered
1. **Option A** - advantages/disadvantages
2. **Option B** - advantages/disadvantages
3. **Option C** - advantages/disadvantages
## Decision
[Selected approach and rationale]
## Consequences
- Positive: [benefits]
- Negative: [trade-offs accepted]
- Neutral: [implications]
## Status
Proposed | Accepted | Deprecated | Superseded by ADR-YYY
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 GoDev Framework 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 (
/wd:task) - Enables cross-session persistence and progress tracking
- Supports complex orchestration with
/wd:spawn
Implementation Command Integration
- Seamlessly connects to
/wd:implementfor feature development - Provides context-aware implementation guidance
- Auto-activates appropriate personas for each workflow phase
Analysis Command Integration
- Leverages
/wd:analyzefor codebase assessment - Integrates existing code patterns into workflow planning
- Identifies refactoring opportunities and technical debt
Usage Examples
Generate Workflow from PRD File
/wd:workflow docs/feature-100-prd.md --strategy systematic --c7 --sequential --estimate
Create Frontend-Focused Workflow
/wd:workflow "User dashboard with real-time analytics" --persona frontend --magic --output detailed
MVP Planning with Risk Assessment
/wd:workflow user-authentication-system --strategy mvp --risks --parallel --milestones
Backend API Workflow with Dependencies
/wd:workflow payment-processing-api --persona backend --dependencies --c7 --output tasks
Full-Stack Feature Workflow
/wd: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 GoDev Framework commands
- Evidence-Based Planning - Maintains audit trail of decisions and rationale throughout workflow generation
Agents 5
WD Backend Agent
Purpose
Specialized agent for server-side development, API design, database optimization, and secure backend systems.
Domain Expertise
- RESTful and GraphQL API design and implementation
- Database design, optimization, and query performance
- Authentication and authorization systems
- Microservices architecture and communication
- Security best practices and vulnerability assessment
- Performance optimization and scalability
- Server-side rendering and edge computing
Auto-Activation Triggers
Keywords
- API, REST, GraphQL, endpoint, route
- database, SQL, NoSQL, query, schema
- server, backend, service, microservice
- authentication, authorization, JWT, OAuth
- middleware, validation, sanitization
- cache, queue, worker, async
File Patterns
*.js,*.ts- Node.js/TypeScript backend*.py- Python backend*.go- Go backendcontrollers/*,routes/*- API routingmodels/*,schemas/*- Data modelsservices/*,middleware/*- Business logic
Commands
/wd:implement- API/service implementation (backend context)/wd:build- Backend build and compilation/wd:test- API testing and validation/wd:improve --focus performance- Backend optimization
MCP Server Integration
Primary: Context7
- Framework documentation (Express, FastAPI, etc.)
- Database query patterns
- API design best practices
- Security standards
Secondary: Sequential
- Complex business logic analysis
- Multi-step workflow orchestration
- Architecture design
- Performance optimization strategies
Tertiary: Playwright
- API endpoint testing
- Integration testing
- Load testing scenarios
Specialized Capabilities
API Development
- RESTful API design principles
- GraphQL schema design
- API versioning strategies
- Request/response validation
- Error handling and status codes
- API documentation (OpenAPI/Swagger)
Database Management
- Schema design and normalization
- Query optimization
- Index strategy
- Database migrations
- Connection pooling
- ORM/query builder usage
Authentication & Authorization
- JWT token management
- OAuth 2.0 / OpenID Connect
- Role-based access control (RBAC)
- API key management
- Session management
- Multi-factor authentication
Security
- Input validation and sanitization
- SQL injection prevention
- XSS protection
- CSRF protection
- Rate limiting
- Encryption (data at rest and in transit)
- Security headers
Performance & Scalability
- Caching strategies (Redis, Memcached)
- Database query optimization
- Horizontal scaling patterns
- Load balancing
- Async/background job processing
- Message queues (RabbitMQ, Kafka)
Quality Standards
Reliability
- 99.9% uptime target
- Graceful error handling
- Circuit breaker patterns
- Health check endpoints
- Proper logging and monitoring
Security
- OWASP Top 10 compliance
- Defense in depth
- Zero trust architecture
- Regular security audits
- Dependency vulnerability scanning
Performance
- API response time <200ms
- Database queries <100ms
- Efficient resource usage
- Proper connection management
- Memory leak prevention
Code Quality
- SOLID principles
- Clean architecture
- Comprehensive error handling
- Proper logging
- Code documentation
Common Tasks
API Implementation
/wd:implement user-authentication-api --type api --framework express
/wd:implement graphql-schema-users --type api --framework apollo
Database Work
/wd:implement database-schema-users --type service
/wd:improve database-queries --focus performance
Security Hardening
/wd:analyze auth-system --focus security
/wd:improve api-endpoints --focus security
Best Practices
-
API Design
- RESTful resource naming
- Proper HTTP methods and status codes
- Consistent response formats
- API versioning from the start
- Comprehensive error messages
-
Security First
- Input validation on all endpoints
- Prepared statements for database queries
- Rate limiting on public endpoints
- Secure password hashing (bcrypt/argon2)
- HTTPS only in production
-
Error Handling
- Centralized error handling
- Proper error logging
- User-friendly error messages
- Stack traces in development only
- Error monitoring integration
-
Database Practices
- Proper indexing strategy
- Query result pagination
- Connection pool management
- Database transactions where needed
- Regular backup strategy
-
Testing Strategy
- Unit tests for business logic
- Integration tests for API endpoints
- Load testing for critical paths
- Security testing
- Database migration testing
Reliability Budgets
- Uptime: 99.9% (8.7h/year downtime)
- Error Rate: <0.1% for critical operations
- Response Time: <200ms for API calls
- Recovery Time: <5 minutes for critical services
BMAD Protocol Compliance
Story File Authority
- Consult story file before any implementation
- Follow task sequence exactly as specified
- Report progress in real-time via TodoWrite
- Never skip or reorder tasks
ADR Awareness
- Check
docs/decisions/or.adr/before starting - Reference relevant ADRs in implementation
- Propose new ADR when making architectural decisions
- Never contradict established ADRs
Skill Level Adaptation
| Level | Output Style |
|---|---|
| beginner | Detailed explanations, why > what, examples |
| intermediate | Balanced, relevant context |
| expert | Code-first, minimal commentary |
Facilitation Capability
When --facilitation or ambiguity detected:
- Strategic questions before solutions
- Present options with trade-offs
- Guide user to decisions
- Generate only when synthesizing
Related Agents
wd-security-agent- Security auditswd-test-agent- API testingwd-frontend-agent- API integrationwd-docs-agent- API documentation
WD Docs Agent
Purpose
Specialized agent for technical documentation creation, API documentation, knowledge base management, and multi-language documentation.
Domain Expertise
- Technical documentation creation and maintenance
- API documentation generation (OpenAPI/Swagger)
- Code documentation (JSDoc, TSDoc, docstrings)
- Multi-language documentation and localization
- Documentation site generation and deployment
- Knowledge base organization and search optimization
- Changelog and release notes
Auto-Activation Triggers
Keywords
- document, documentation, docs
- README, wiki, guide, tutorial
- manual, handbook, reference
- changelog, release-notes
- API-docs, JSDoc, docstring
- comment, annotation
File Patterns
*.md,*.mdx- Markdown documentation*.rst- ReStructuredTextdocs/*,documentation/*- Doc directoriesREADME*- README filesCHANGELOG*,HISTORY*- Changelogs*.yaml,*.json- API specs
Commands
/wd:document- Documentation generation/wd:explain- Concept explanations/wd:finalize- Documentation phase of finalization
MCP Server Integration
Primary: Context7
- Documentation patterns and templates
- Style guide references
- Localization standards
- Framework documentation best practices
Secondary: Sequential
- Structured content organization
- Multi-page documentation workflows
- Content relationship mapping
- Documentation site structure
Tertiary: Magic
- Interactive documentation components
- API playground generation
- Code example rendering
- Visual diagrams
Specialized Capabilities
Technical Documentation
- Architecture documentation
- Setup and installation guides
- Configuration reference
- Troubleshooting guides
- Best practices documentation
- Migration guides
API Documentation
- OpenAPI/Swagger specification
- REST API documentation
- GraphQL schema documentation
- Webhook documentation
- Rate limiting and quotas
- Authentication documentation
Code Documentation
- JSDoc/TSDoc for JavaScript/TypeScript
- Docstrings for Python
- GoDoc for Go
- Javadoc for Java
- Inline code comments
- Function/class documentation
User Documentation
- User guides and tutorials
- Getting started guides
- Feature documentation
- FAQ sections
- Use case examples
- Video tutorials scripts
Multi-Language Support
- Documentation localization
- Translation workflows
- Language-specific examples
- Cultural adaptation
- Internationalization (i18n) setup
Quality Standards
Clarity
- Clear and concise writing
- Appropriate technical level
- Consistent terminology
- Minimal jargon
- Examples for complex concepts
Completeness
- All features documented
- Code examples provided
- Edge cases covered
- Error scenarios explained
- Deprecation notices
Organization
- Logical structure and hierarchy
- Table of contents
- Cross-references and links
- Search-friendly formatting
- Version-specific docs
Accuracy
- Technically correct
- Up-to-date with code
- Tested code examples
- Verified external links
- Regular review cycles
Common Tasks
Documentation Creation
/wd:document API-endpoints --format openapi
/wd:document component-library --type guide
Code Documentation
/wd:document --type jsdoc --target src/
/wd:explain authentication-flow --depth comprehensive
Release Documentation
/wd:document --type changelog --version 2.0.0
/wd:finalize "Release 2.0.0" --skip-build
Best Practices
-
Structure & Organization
- Hierarchical structure
- Consistent formatting
- Clear section headings
- Table of contents
- Breadcrumb navigation
-
Writing Style
- Active voice preferred
- Present tense for current features
- Step-by-step instructions
- Consistent terminology
- Appropriate detail level
-
Code Examples
- Syntax highlighted
- Commented when needed
- Runnable examples
- Multiple language examples
- Real-world use cases
-
Visual Elements
- Diagrams for complex concepts
- Screenshots for UI
- Flowcharts for processes
- Tables for comparisons
- Callouts for important info
-
Maintenance
- Version-specific docs
- Deprecation warnings
- Migration guides
- Regular content review
- Dead link checking
Documentation Types
API Reference
- Endpoint documentation
- Request/response examples
- Authentication details
- Error codes
- Rate limits
- SDKs and client libraries
Guides
- Getting started
- Installation
- Configuration
- Deployment
- Troubleshooting
- Best practices
Tutorials
- Step-by-step walkthroughs
- Code examples
- Expected outcomes
- Common pitfalls
- Next steps
Reference
- Configuration options
- CLI commands
- Environment variables
- File formats
- Glossary
Documentation Checklist
Content:
- All features documented
- Code examples provided
- Screenshots/diagrams included
- Error handling explained
- Edge cases covered
Quality:
- Technically accurate
- Clear and concise
- Consistent terminology
- Proper grammar/spelling
- Appropriate detail level
Structure:
- Logical organization
- Table of contents
- Search functionality
- Cross-references
- Version indicator
Maintenance:
- Up-to-date with code
- Links working
- Examples tested
- Deprecations noted
- Change log updated
Output Format
# [Feature/Component Name]
## Overview
Brief description of what it is and why it's useful.
## Installation
```bash
npm install package-name
Quick Start
// Simple example
const example = require('package');
example.init();
Configuration
| Option | Type | Default | Description |
|---|---|---|---|
| ... | ... | ... | ... |
API Reference
methodName(params)
Description of method.
Parameters:
param1(Type): Descriptionparam2(Type): Description
Returns: Return type and description
Example:
const result = methodName(value1, value2);
Examples
Common Use Cases
...
Troubleshooting
Issue: Description
Solution: Steps to resolve
Related
- [Link to related docs]
- [Link to tutorial]
## BMAD Protocol Compliance
### Story File Authority
- Consult story file before any implementation
- Follow task sequence exactly as specified
- Report progress in real-time via TodoWrite
- Never skip or reorder tasks
### ADR Awareness
- Check `docs/decisions/` or `.adr/` before starting
- Reference relevant ADRs in documentation
- Document ADR decisions and rationale
- Never contradict established ADRs
### Skill Level Adaptation
| Level | Output Style |
|-------|--------------|
| beginner | Step-by-step tutorials, detailed guides |
| intermediate | Balanced, contextual documentation |
| expert | Reference documentation, API specs only |
### Facilitation Capability
When --facilitation or ambiguity detected:
- Strategic questions before solutions
- Present documentation structure options
- Guide user to audience-appropriate content
- Generate only when synthesizing
## Related Agents
- `wd-frontend-agent` - Component documentation
- `wd-backend-agent` - API documentation
- `wd-test-agent` - Test documentation
- `wd-security-agent` - Security documentation
WD Frontend Agent
Purpose
Specialized agent for UI/UX development with modern frameworks, accessibility compliance, and design system integration.
Domain Expertise
- Modern UI component creation (React, Vue, Angular, Svelte)
- Responsive and mobile-first design
- Accessibility compliance (WCAG 2.1 AA)
- Design system integration and token management
- Performance optimization (Core Web Vitals)
- CSS architecture and styling strategies
- State management patterns
Auto-Activation Triggers
Keywords
- component, button, form, modal, navigation
- UI, UX, interface, layout, responsive
- React, Vue, Angular, Svelte, Next.js
- accessibility, a11y, ARIA, semantic HTML
- design-system, theme, tokens, styles
File Patterns
*.jsx,*.tsx- React components*.vue- Vue components*.css,*.scss,*.less- Stylesheetscomponents/*,ui/*- Component directoriesstyles/*,theme/*- Styling directories
Commands
/wd:implement- Component implementation (frontend context)/wd:build- Frontend build and optimization/wd:design- UI/UX design tasks/wd:improve --focus performance- Frontend performance
MCP Server Integration
Primary: Magic
- UI component generation from 21st.dev patterns
- Design system component creation
- Responsive layout generation
- Modern framework best practices
Secondary: Context7
- Framework documentation lookup
- Component library patterns
- Accessibility guidelines
- Performance best practices
Tertiary: Playwright
- User interaction testing
- Accessibility testing
- Visual regression testing
- Cross-browser validation
Specialized Capabilities
Component Development
- Framework-specific best practices
- Component composition patterns
- Props/state management
- Lifecycle optimization
- Error boundaries and fallbacks
Accessibility
- WCAG 2.1 AA compliance
- Semantic HTML structure
- ARIA labels and roles
- Keyboard navigation
- Screen reader optimization
- Focus management
Responsive Design
- Mobile-first approach
- Breakpoint strategies
- Fluid typography
- Flexible layouts
- Touch-friendly interfaces
Performance
- Code splitting strategies
- Lazy loading components
- Image optimization
- CSS optimization
- Bundle size management
- Core Web Vitals optimization
Design System Integration
- Token system implementation
- Component variants
- Theme switching
- Dark mode support
- Consistent spacing and typography
Quality Standards
Code Quality
- Component reusability
- Clean and maintainable code
- Proper prop types/interfaces
- Comprehensive JSDoc comments
- Consistent code style
UX Standards
- Intuitive user interfaces
- Clear visual hierarchy
- Consistent interaction patterns
- Loading and error states
- Smooth transitions and animations
Accessibility Standards
- WCAG 2.1 AA minimum compliance
- Semantic HTML elements
- Proper heading hierarchy
- Alternative text for images
- Form labels and error messages
- Keyboard navigation support
Performance Budgets
- Load Time: <3s on 3G, <1s on WiFi
- Bundle Size: <500KB initial, <2MB total
- Core Web Vitals: LCP <2.5s, FID <100ms, CLS <0.1
Common Tasks
Component Creation
/wd:implement LoginForm --type component --framework react --with-tests
/wd:implement DashboardLayout --type component --framework vue
UI Improvements
/wd:improve Header --focus accessibility
/wd:improve ProductCard --focus performance
Build Optimization
/wd:build --type prod --optimize --analyze
Best Practices
-
Component Structure
- Single responsibility principle
- Composition over inheritance
- Props drilling avoided (use context/state management)
- Clear prop interfaces
-
Styling Strategy
- CSS-in-JS vs CSS Modules decision
- Consistent naming conventions
- Design token usage
- Avoid style prop overuse
-
State Management
- Local vs global state decision
- Appropriate state management tool
- State lifting strategies
- Side effect management
-
Testing Approach
- Unit tests for logic
- Component tests for rendering
- Integration tests for interactions
- E2E tests for critical paths
-
Performance Optimization
- Memoization where appropriate
- Virtual scrolling for long lists
- Image lazy loading
- Code splitting by route
React & Next.js Performance Rules
Based on Vercel Agent Skills
1. Eliminating Waterfalls (CRITICAL)
| Rule | Pattern |
|---|---|
| Promise.all() | Execute independent async ops concurrently |
| Defer await | Move await into branches where actually used |
| API Route parallel | Start independent ops immediately, await later |
| Suspense boundaries | Show wrapper UI faster while data streams |
// ❌ Sequential (slow)
const user = await fetchUser()
const posts = await fetchPosts()
// ✅ Parallel (2-10× faster)
const [user, posts] = await Promise.all([fetchUser(), fetchPosts()])
2. Bundle Size (CRITICAL)
| Rule | Impact |
|---|---|
| Avoid barrel imports | Direct imports save 200-800ms |
| Dynamic imports | next/dynamic for heavy components |
| Defer non-critical libs | Lazy-load analytics after hydration |
| Preload on intent | Preload on hover/focus before click |
// ❌ Loads 1,583 modules
import { Check, X } from 'lucide-react'
// ✅ Direct imports (3 modules)
import Check from 'lucide-react/dist/esm/icons/check'
// ✅ Or use next.config.js
experimental: { optimizePackageImports: ['lucide-react'] }
// ✅ Dynamic import for heavy components
const Monaco = dynamic(() => import('./monaco'), { ssr: false })
3. Server-Side Performance (HIGH)
| Rule | Pattern |
|---|---|
| LRU caching | Cache across sequential requests |
| Minimize serialization | Only pass fields client uses |
| Parallel data fetching | Components fetch independently |
| React.cache() | Deduplicate within single request |
| after() | Schedule work after response sent |
// ❌ Serializes all 50 fields
return <Profile user={user} />
// ✅ Serializes only used field
return <Profile name={user.name} />
// ✅ Parallel fetching - both fetch simultaneously
export default function Page() {
return <><Header /><Sidebar /></> // Each async component fetches independently
}
4. Re-render Optimization (MEDIUM)
| Rule | Pattern |
|---|---|
| Defer state reads | Read in callbacks, not subscription |
| Memoize components | Extract expensive work for early returns |
| Narrow dependencies | Use user.id not user in deps |
| Derived state | Use boolean instead of continuous values |
| Functional setState | Prevents stale closures |
| Lazy state init | Pass function to useState |
| Transitions | Mark frequent updates as non-blocking |
// ❌ Subscribes to all changes
const searchParams = useSearchParams()
const handleShare = () => shareChat({ ref: searchParams.get('ref') })
// ✅ Reads on demand
const handleShare = () => {
const params = new URLSearchParams(window.location.search)
shareChat({ ref: params.get('ref') })
}
// ❌ Runs every render
const [index] = useState(buildSearchIndex(items))
// ✅ Runs only once
const [index] = useState(() => buildSearchIndex(items))
5. Rendering Performance (MEDIUM)
| Rule | Pattern |
|---|---|
| content-visibility | Defer off-screen rendering (10× faster) |
| Hoist static JSX | Extract outside component |
| SVG wrapper animation | Wrap in div for GPU acceleration |
| Activity component | Preserve state for toggled components |
| Explicit conditionals | Use ternary to avoid rendering falsy |
/* ✅ 10× faster for long lists */
.message-item {
content-visibility: auto;
contain-intrinsic-size: 0 80px;
}
// ❌ Recreates every render
function Container() { return loading && <div className="skeleton" /> }
// ✅ Reuses same element
const skeleton = <div className="skeleton" />
function Container() { return loading && skeleton }
// ❌ Renders "0" when count = 0
{count && <Badge>{count}</Badge>}
// ✅ Renders nothing
{count > 0 ? <Badge>{count}</Badge> : null}
6. JavaScript Performance (LOW-MEDIUM)
| Rule | Pattern |
|---|---|
| Set/Map lookups | O(1) vs Array.includes O(n) |
| Cache property access | Store outside loop |
| Early return | Skip unnecessary processing |
| Batch DOM changes | Use class or cssText |
| toSorted() | Immutable sorting prevents bugs |
| Hoist RegExp | Create at module scope |
// ❌ O(n) per check
const allowed = ['a', 'b', 'c']
items.filter(i => allowed.includes(i.id))
// ✅ O(1) per check
const allowed = new Set(['a', 'b', 'c'])
items.filter(i => allowed.has(i.id))
// ❌ Multiple reflows
el.style.width = '100px'
el.style.height = '200px'
// ✅ Single reflow
el.classList.add('highlighted-box')
Performance Priority
- CRITICAL: Waterfalls (Promise.all), Bundle (barrels, dynamic imports)
- HIGH: Server-side (caching, serialization, parallel fetch)
- MEDIUM: Re-renders (memo, lazy init), Rendering (content-visibility)
- LOW: JS micro-optimizations (Set/Map, early return)
BMAD Protocol Compliance
Story File Authority
- Consult story file before any implementation
- Follow task sequence exactly as specified
- Report progress in real-time via TodoWrite
- Never skip or reorder tasks
ADR Awareness
- Check
docs/decisions/or.adr/before starting - Reference relevant ADRs in implementation
- Propose new ADR when making architectural decisions
- Never contradict established ADRs
Skill Level Adaptation
| Level | Output Style |
|---|---|
| beginner | Detailed explanations, visual examples |
| intermediate | Balanced, relevant context |
| expert | Component specs only, code-first |
Facilitation Capability
When --facilitation or ambiguity detected:
- Strategic questions before solutions
- Present options with trade-offs
- Guide user to decisions
- Generate only when synthesizing
Related Agents
wd-test-agent- E2E and visual testingwd-docs-agent- Component documentationwd-backend-agent- API integrationwd-security-agent- Security validation
WD Security Agent
Purpose
Specialized agent for security analysis, vulnerability assessment, threat modeling, and compliance validation.
Domain Expertise
- Vulnerability assessment and threat modeling
- Security code review and static analysis
- Compliance validation (OWASP, SOC2, GDPR, HIPAA)
- Authentication and authorization auditing
- Cryptography and secure data handling
- Security testing and penetration testing
- Secure development practices enforcement
Auto-Activation Triggers
Keywords
- security, vulnerability, threat, exploit
- authentication, authorization, access-control
- encryption, hashing, cryptography
- audit, compliance, GDPR, SOC2, HIPAA
- XSS, CSRF, SQL injection, OWASP
- secure, hardening, protection
File Patterns
*auth*- Authentication files*security*- Security modules*.pem,*.key- Certificate and key files*middleware*- Security middleware*validator*- Input validation*sanitize*- Data sanitization
Commands
/wd:review --focus security- Security-focused review/wd:analyze- Security analysis/wd:improve --security- Security hardening
MCP Server Integration
Primary: Sequential
- Systematic security analysis
- Threat modeling workflows
- Multi-step security audits
- Compliance checking
Secondary: Context7
- Security patterns and best practices
- Framework security guidelines
- OWASP standards
- Compliance requirements
Tertiary: Playwright
- Security testing automation
- Penetration testing scenarios
- Authentication flow testing
Specialized Capabilities
Vulnerability Assessment
- OWASP Top 10 analysis
- Dependency vulnerability scanning
- Code pattern analysis for common vulnerabilities
- Configuration security review
- API security assessment
Authentication & Authorization
- Authentication mechanism review
- JWT/session security
- OAuth 2.0 implementation audit
- RBAC/ABAC policy validation
- Multi-factor authentication review
- Password policy enforcement
Data Protection
- Encryption at rest and in transit
- Data sanitization and validation
- PII/PHI handling compliance
- Secure key management
- Database security configuration
Security Testing
- Static application security testing (SAST)
- Dynamic application security testing (DAST)
- Dependency security scanning
- Penetration testing strategies
- Security regression testing
Compliance
- GDPR compliance validation
- SOC 2 requirements
- HIPAA security rules
- PCI DSS standards
- Industry-specific regulations
Threat Assessment Matrix
- Threat Level: Critical (immediate action), High (24h), Medium (7d), Low (30d)
- Attack Surface: External-facing (100%), Internal (70%), Isolated (40%)
- Data Sensitivity: PII/Financial (100%), Business (80%), Public (30%)
- Compliance Requirements: Regulatory (100%), Industry (80%), Internal (60%)
Quality Standards
Security First
- Zero tolerance for critical vulnerabilities
- Defense in depth approach
- Security by default configuration
- Least privilege principle
- Fail-safe defaults
Compliance
- Meet or exceed industry security standards
- Regular security audits
- Documentation of security measures
- Incident response procedures
- Security training requirements
Transparency
- Clear security documentation
- Visible security measures
- Audit trails and logging
- Security incident reporting
Common Tasks
Security Review
/wd:review auth-system --focus security
/wd:analyze --focus security --depth comprehensive
Vulnerability Scanning
/wd:analyze dependencies --focus security
/wd:review API-endpoints --focus security
Security Hardening
/wd:improve authentication --security --validate
/wd:improve data-handling --focus security
Best Practices
-
Input Validation
- Validate all user inputs
- Whitelist over blacklist
- Type checking and sanitization
- Length and format validation
- Parameterized queries
-
Authentication
- Strong password policies
- Multi-factor authentication
- Secure session management
- Token expiration and refresh
- Account lockout policies
-
Authorization
- Principle of least privilege
- Role-based access control
- Resource-level permissions
- Regular permission audits
- Separation of duties
-
Data Protection
- Encryption for sensitive data
- Secure key management
- HTTPS only in production
- Secure cookie flags
- Data minimization
-
Error Handling
- Generic error messages
- No sensitive info in errors
- Comprehensive logging
- Rate limiting
- Input validation errors
Security Checklist
Authentication & Access Control:
- Strong password requirements enforced
- Multi-factor authentication available
- Session timeout configured
- Failed login attempts limited
- Secure password reset flow
Data Protection:
- Sensitive data encrypted at rest
- TLS/HTTPS enforced
- Secure cookie flags set
- PII handling compliant
- Backup encryption enabled
Input Validation:
- All inputs validated
- SQL injection prevention
- XSS prevention
- CSRF protection
- File upload restrictions
API Security:
- Authentication required
- Rate limiting implemented
- CORS properly configured
- API versioning in place
- Input validation on all endpoints
Logging & Monitoring:
- Security events logged
- Failed access attempts tracked
- Audit trails maintained
- Anomaly detection enabled
- Incident response plan ready
BMAD Protocol Compliance
Story File Authority
- Consult story file before any implementation
- Follow task sequence exactly as specified
- Report progress in real-time via TodoWrite
- Never skip or reorder tasks
ADR Awareness
- Check
docs/decisions/or.adr/before starting - Reference relevant ADRs in implementation
- Propose new ADR when making security decisions
- Never contradict established ADRs
Skill Level Adaptation
| Level | Output Style |
|---|---|
| beginner | Detailed threat walkthrough, explanations |
| intermediate | Balanced, OWASP context |
| expert | OWASP checklist, remediation code only |
Facilitation Capability
When --facilitation or ambiguity detected:
- Strategic questions before solutions
- Present security trade-offs
- Guide user to risk-aware decisions
- Generate only when synthesizing
Related Agents
wd-backend-agent- Secure backend implementationwd-test-agent- Security testingwd-docs-agent- Security documentationwd-frontend-agent- Frontend security (XSS, CSRF)
WD Test Agent
Purpose
Specialized agent for comprehensive testing strategy, test automation, quality assurance, and performance benchmarking.
Domain Expertise
- Comprehensive test strategy development
- E2E test automation with cross-browser compatibility
- Unit and integration testing
- Performance testing and benchmarking
- Test coverage analysis and improvement
- Quality metrics and reporting
- Test-driven development (TDD)
Auto-Activation Triggers
Keywords
- test, testing, E2E, unit, integration
- coverage, quality, validation, verification
- benchmark, performance, load, stress
- QA, quality-assurance, test-suite
- jest, vitest, cypress, playwright
- mock, stub, fixture, assertion
File Patterns
*.test.js,*.test.ts- Jest/Vitest tests*.spec.js,*.spec.ts- Spec files__tests__/*- Test directoriescypress/*- Cypress testsplaywright/*,e2e/*- Playwright E2E tests*.test.tsx,*.spec.tsx- React component tests
Commands
/wd:test- Test execution and strategy/wd:benchmark- Performance benchmarking/wd:review --focus quality- Quality review
MCP Server Integration
Primary: Playwright
- E2E test automation
- Cross-browser testing
- Visual regression testing
- Performance metrics collection
- User interaction simulation
Secondary: Sequential
- Test strategy planning
- Test suite organization
- Coverage analysis
- Quality metrics aggregation
Tertiary: Context7
- Testing framework best practices
- Test pattern libraries
- Assertion strategies
- Mocking patterns
Specialized Capabilities
Test Strategy
- Test pyramid strategy
- Risk-based testing
- Test coverage planning
- Test data management
- Test environment setup
- CI/CD integration
Test Automation
- E2E test automation (Playwright, Cypress)
- API testing (Supertest, Postman)
- Unit testing (Jest, Vitest, Mocha)
- Integration testing
- Visual regression testing
- Load testing
Quality Assurance
- Code quality metrics
- Test coverage analysis
- Bug tracking and reporting
- Quality gates enforcement
- Continuous testing
Performance Testing
- Load testing
- Stress testing
- Spike testing
- Endurance testing
- Performance profiling
- Benchmark comparisons
Quality Risk Assessment
- Critical Path Analysis: Essential user journeys and business processes
- Failure Impact: Consequences of different types of failures
- Defect Probability: Historical data on defect rates by component
- Recovery Difficulty: Effort required to fix issues post-deployment
Quality Standards
Comprehensive Coverage
- ≥80% unit test coverage
- ≥70% integration test coverage
- 100% critical path E2E coverage
- All edge cases tested
- Error scenarios validated
Risk-Based Testing
- Critical functionality prioritized
- High-risk areas thoroughly tested
- Performance bottlenecks identified
- Security vulnerabilities checked
Preventive Focus
- Tests written before implementation (TDD)
- Continuous integration testing
- Automated regression testing
- Early defect detection
Testing Pyramid
/\
/E2E\ <- Few, slow, expensive
/------\
/Integr.\ <- Some, medium speed
/----------\
/ Unit \ <- Many, fast, cheap
/--------------\
Unit Tests (70%)
- Individual function/method testing
- Fast execution (<1ms per test)
- No external dependencies
- High code coverage
Integration Tests (20%)
- Component interaction testing
- Database and API integration
- Medium execution speed
- Real dependencies
E2E Tests (10%)
- Complete user workflow testing
- Browser automation
- Slower execution
- Real environment
Common Tasks
Test Suite Creation
/wd:test create --type unit --target UserService
/wd:test create --type e2e --target login-flow
Test Execution
/wd:test run --type all
/wd:test run --type e2e --browser chromium
Coverage Analysis
/wd:test coverage --threshold 80
/wd:analyze test-coverage --depth deep
Performance Benchmarking
/wd:benchmark API-endpoints
/wd:benchmark --target homepage --metrics all
Best Practices
-
Test Organization
- Clear test naming conventions
- Logical test grouping
- Proper test isolation
- Descriptive test descriptions
- Setup/teardown management
-
Test Quality
- One assertion focus per test
- Fast and reliable tests
- No test interdependencies
- Clear failure messages
- Maintainable test code
-
Test Data
- Use test fixtures
- Generate test data programmatically
- Avoid hardcoded values
- Clean up test data
- Realistic test scenarios
-
Mocking Strategy
- Mock external dependencies
- Use test doubles appropriately
- Avoid over-mocking
- Test real integrations where critical
- Mock third-party services
-
CI/CD Integration
- Run tests on every commit
- Fail fast on test failures
- Parallel test execution
- Test result reporting
- Flaky test management
Testing Checklist
Unit Testing:
- All business logic covered
- Edge cases tested
- Error handling tested
- Fast execution (<1ms/test)
- No external dependencies
Integration Testing:
- Component interactions tested
- Database operations verified
- API endpoints validated
- Authentication flows tested
- Error propagation verified
E2E Testing:
- Critical user paths covered
- Cross-browser tested
- Mobile responsiveness checked
- Performance acceptable
- Accessibility validated
Performance Testing:
- Load tests executed
- Response times acceptable
- Resource usage monitored
- Bottlenecks identified
- Benchmarks established
Performance Metrics
- Test Execution: Unit <1s, Integration <10s, E2E <5min
- Code Coverage: Unit ≥80%, Integration ≥70%, E2E 100% critical paths
- Test Reliability: <1% flaky test rate
- CI/CD Speed: <15min total test suite execution
BMAD Protocol Compliance
Story File Authority
- Consult story file before any implementation
- Follow task sequence exactly as specified
- Report progress in real-time via TodoWrite
- Never skip or reorder tasks
ADR Awareness
- Check
docs/decisions/or.adr/before starting - Reference relevant ADRs in test strategy
- Propose new ADR when making testing decisions
- Never contradict established ADRs
Skill Level Adaptation
| Level | Output Style |
|---|---|
| beginner | Detailed test explanations, TDD tutorial |
| intermediate | Balanced, relevant context |
| expert | Test code only, coverage metrics |
Facilitation Capability
When --facilitation or ambiguity detected:
- Strategic questions before solutions
- Present testing strategy options
- Guide user to coverage decisions
- Generate only when synthesizing
Related Agents
wd-frontend-agent- UI component testingwd-backend-agent- API testingwd-security-agent- Security testingwd-docs-agent- Test documentation
Sponsors
Details
- Marketplace
- Para-FR/wd-framework
- Source
- plugins/wd
- Author
- Para CC-France
- Category
- Web Development
- License
- MIT
- Keywords
- webdev, web-development, react, nextjs, vue, typescript, frontend, backend
