14 KiB

Raw Blame History

Developer (Dev) - Integration Guide

Environment Setup

IDE Environment Setup

The Developer persona is optimized for IDE-based development workflows with comprehensive tooling integration.

Initial Configuration

Load persona configuration

# Copy persona files to IDE agent configuration
cp bmad-agent/personas/dev.ide.md ~/.ai/personas/

# Verify persona activation
echo "Developer persona loaded: Expert Senior Software Engineer"

Set up working directories

# Create essential project structure
mkdir -p {docs/stories,docs/checklists,scripts,.ai}

# Initialize debug log
touch .ai/TODO-revert.md

# Verify directory structure
tree -L 2 docs/

Configure development environment

# Install essential development tools
npm install -g eslint prettier jest
pip install pylint black pytest

# Configure git hooks for quality checks
git config core.hooksPath .githooks

Web Environment Integration

For teams using web-based development environments, the Developer persona can be adapted for browser-based workflows.

Configuration Steps

Access development workspace

Navigate to your development environment (GitHub Codespaces, GitPod, etc.)
Load BMAD Method configuration
Select "Developer" persona from available personas

Verify integration points

Confirm access to story files in docs/stories/
Validate connection to project management tools
Test CI/CD pipeline integration

BMAD Method Workflow Integration

Phase 1: Story Assignment and Initialization

Entry Points

The Developer typically receives work through formal story assignment from Product Owners.

# Story Assignment Process
1. **Story Creation**: Product Owner creates detailed story with acceptance criteria
2. **Technical Review**: System Architect validates technical feasibility
3. **Story Approval**: Story status updated to "Approved" and ready for development
4. **Developer Assignment**: Story assigned to specific developer for implementation
5. **Development Initiation**: Developer updates story status to "InProgress"

Handoff Procedures

# From Product Owner (Sarah)
- Receive detailed user story with clear acceptance criteria
- Understand business context and user value proposition
- Clarify any ambiguous requirements or edge cases
- Confirm story priority and timeline expectations

# From System Architect (Fred)
- Review technical specifications and architecture guidelines
- Understand integration points and system constraints
- Validate technical approach and implementation strategy
- Confirm compliance with established architectural patterns

# From UX/UI Architect
- Receive design specifications and component requirements
- Understand user experience expectations and interaction patterns
- Clarify responsive design and accessibility requirements
- Coordinate on design system usage and component implementation

Phase 2: Development Execution

Core Development Workflow

# Standard Development Process
1. **Story Analysis**: Thorough review of requirements and acceptance criteria
2. **Technical Planning**: Break down story into implementable tasks
3. **Implementation**: Code development following established standards
4. **Testing**: Comprehensive test suite development and execution
5. **Quality Assurance**: Code review, linting, and security scanning
6. **Documentation**: Technical documentation and API documentation updates
7. **Integration**: Validation of integration points and system compatibility

Quality Gates Integration

# Mandatory Quality Checkpoints
- **Code Standards**: All code must pass linting and style checks
- **Test Coverage**: Minimum test coverage thresholds must be met
- **Security Scan**: No high-severity security vulnerabilities allowed
- **Performance**: Performance benchmarks must be maintained or improved
- **Documentation**: All public APIs and complex logic must be documented

Phase 3: Review and Handoff

Definition of Done (DoD) Process

# DoD Checklist Validation
1. **Functional Requirements**: All acceptance criteria are met and validated
2. **Technical Standards**: Code meets all established quality standards
3. **Testing Requirements**: Comprehensive test suite with adequate coverage
4. **Documentation**: Technical and user documentation is complete
5. **Integration**: Feature integrates properly with existing system
6. **Performance**: Performance requirements are met or exceeded
7. **Security**: Security requirements and best practices are implemented

Downstream Handoffs

# To DevOps Engineer
- Deployable code with clear deployment instructions
- Configuration requirements and environment variables
- Database migration scripts and data requirements
- Monitoring and alerting configuration needs

# To QA Team
- Testable features with comprehensive test documentation
- Test data requirements and setup instructions
- Known limitations or edge cases requiring validation
- User acceptance testing guidance and criteria

# To Product Owner
- Completed story ready for acceptance testing
- Demo-ready feature with usage instructions
- Documentation of any scope changes or technical decisions
- Recommendations for future enhancements or optimizations

Third-Party Tool Integrations

Development Tools Integration

Version Control Systems

# Git Integration
- **GitHub**: Pull request workflows, code review processes, CI/CD integration
- **GitLab**: Merge request workflows, built-in CI/CD, issue tracking
- **Bitbucket**: Atlassian ecosystem integration, Jira connectivity

# Setup Process
1. Configure branch protection rules and review requirements
2. Set up automated testing and quality checks on pull requests
3. Establish merge strategies and deployment workflows
4. Configure issue linking and project management integration

Integrated Development Environments

# IDE Integration Options
- **VS Code**: Extensions for BMAD Method, debugging, testing, and collaboration
- **IntelliJ IDEA**: Plugin ecosystem, advanced debugging, refactoring tools
- **Eclipse**: Java development, plugin architecture, team collaboration features

# Configuration Steps
1. Install BMAD Method extensions and plugins
2. Configure code formatting and linting rules
3. Set up debugging configurations and test runners
4. Integrate with version control and project management tools

Testing and Quality Assurance Tools

Testing Frameworks

# Frontend Testing
- **Jest**: Unit testing, snapshot testing, mocking capabilities
- **Cypress**: End-to-end testing, visual testing, API testing
- **React Testing Library**: Component testing, accessibility testing

# Backend Testing
- **JUnit**: Java unit testing, integration testing, parameterized tests
- **pytest**: Python testing, fixtures, parametrization, plugins
- **Mocha/Chai**: Node.js testing, assertion library, test organization

# Setup Process
1. Configure test runners and reporting tools
2. Set up continuous testing in development environment
3. Integrate with CI/CD pipelines for automated testing
4. Establish test data management and cleanup procedures

Code Quality Tools

# Static Analysis
- **SonarQube**: Comprehensive code quality analysis, technical debt tracking
- **CodeClimate**: Automated code review, maintainability scoring
- **ESLint/Pylint**: Language-specific linting and style enforcement

# Security Scanning
- **Snyk**: Dependency vulnerability scanning, license compliance
- **OWASP ZAP**: Dynamic application security testing
- **Bandit**: Python security linting, common security issues detection

# Setup Process
1. Configure quality gates and thresholds
2. Integrate with development workflow and CI/CD
3. Set up automated reporting and notifications
4. Establish remediation workflows for identified issues

Project Management Integration

Agile and Project Management Tools

# Integration Options
- **Jira**: Story tracking, sprint management, reporting and analytics
- **Azure DevOps**: End-to-end development lifecycle, work item tracking
- **GitHub Issues**: Lightweight issue tracking, project boards, automation
- **Linear**: Modern issue tracking, project management, team collaboration

# Setup Process
1. Configure story templates and workflow states
2. Establish linking between code commits and stories
3. Set up automated status updates and notifications
4. Create reporting dashboards and team metrics

Communication and Collaboration

# Team Communication
- **Slack**: Channel-based communication, bot integrations, file sharing
- **Microsoft Teams**: Enterprise communication, video conferencing, file collaboration
- **Discord**: Community-style communication, voice channels, screen sharing

# Documentation Platforms
- **Confluence**: Team knowledge base, technical documentation, collaboration
- **Notion**: All-in-one workspace, documentation, project management
- **GitBook**: Technical documentation, API documentation, team knowledge sharing

# Setup Process
1. Create dedicated channels for development team communication
2. Configure automated notifications for build status and deployments
3. Set up shared workspaces for documentation and knowledge sharing
4. Establish communication protocols and escalation procedures

Continuous Integration/Continuous Deployment (CI/CD) Integration

Pipeline Configuration

# CI/CD Pipeline Stages
1. **Source Control**: Code commit triggers automated pipeline
2. **Build**: Compile code, resolve dependencies, create artifacts
3. **Test**: Execute unit tests, integration tests, security scans
4. **Quality Gates**: Code quality checks, coverage thresholds, security validation
5. **Deploy**: Automated deployment to staging and production environments
6. **Monitor**: Post-deployment monitoring, alerting, and validation

Popular CI/CD Platforms

# Platform Options
- **GitHub Actions**: Native GitHub integration, marketplace of actions
- **GitLab CI/CD**: Built-in GitLab functionality, Docker integration
- **Jenkins**: Self-hosted, extensive plugin ecosystem, enterprise features
- **Azure DevOps**: Microsoft ecosystem integration, comprehensive toolchain
- **CircleCI**: Cloud-based, Docker support, parallel execution

# Setup Considerations
1. Define pipeline stages and quality gates
2. Configure automated testing and deployment strategies
3. Set up environment-specific configurations and secrets management
4. Establish monitoring and alerting for pipeline failures

Quality Assurance Integration

Code Review Process

# Review Workflow
1. **Pre-Review**: Automated checks (linting, testing, security scanning)
2. **Peer Review**: Code review by team members, architecture validation
3. **Approval**: Required approvals from designated reviewers
4. **Merge**: Automated merge after all checks and approvals are complete

# Review Criteria
- Code follows established standards and conventions
- Tests provide adequate coverage and validation
- Documentation is complete and accurate
- Security best practices are implemented
- Performance considerations are addressed

Automated Quality Checks

# Quality Automation
- **Pre-commit Hooks**: Local validation before code commit
- **Pull Request Checks**: Automated validation on code review
- **Continuous Monitoring**: Ongoing quality assessment and reporting
- **Deployment Gates**: Quality validation before production deployment

# Implementation Steps
1. Configure automated quality tools and thresholds
2. Set up quality gates in CI/CD pipeline
3. Establish quality metrics and reporting
4. Create remediation workflows for quality issues

Troubleshooting Integration Issues

Common Integration Challenges

Challenge: CI/CD pipeline failures due to environment differences Solution: Standardize development environments using containers and infrastructure as code

Challenge: Test failures in different environments Solution: Implement comprehensive test data management and environment parity validation

Challenge: Code quality standards inconsistency across team members Solution: Automate quality checks and provide clear guidelines and training

Challenge: Integration conflicts between different development streams Solution: Implement feature branching strategies and regular integration testing

Performance and Scalability Issues

Challenge: Slow build and test execution times Solution: Implement parallel execution, caching strategies, and incremental builds

Challenge: Resource constraints in development environments Solution: Optimize resource usage, implement environment sharing, and cloud-based development

Challenge: Integration bottlenecks during high-velocity development Solution: Implement trunk-based development, feature flags, and continuous integration practices

Support and Escalation Procedures

Internal Support

# Support Channels
- **Technical Documentation**: Comprehensive guides and troubleshooting resources
- **Team Knowledge Base**: Shared solutions and best practices
- **Peer Support**: Code review, pair programming, and mentoring programs
- **Architecture Review**: Regular architecture and design review sessions

External Support

# External Resources
- **Vendor Support**: Direct support from tool and platform providers
- **Community Forums**: Open source communities and professional networks
- **Training and Certification**: Skill development and technology training programs
- **Consulting Services**: Specialized expertise for complex technical challenges

This integration guide provides comprehensive instructions for incorporating the Developer persona into your BMAD Method implementation. For detailed capabilities and quick start instructions, refer to the Comprehensive Guide and Quick Start Guide.

14 KiB Raw Blame History