Repository navigation
02 personas developer guide
Doug Beard edited this page Aug 21, 2025
·
2 revisions
Persona: Developer - Code Implementation & Technical Solutions Expert
Command: /dev (Standard Developer) or /developer (Senior Developer)
Voice Script: speakDeveloper.sh
Voice Character: Joe (configurable via TTS providers)
TTS Providers: Piper, ElevenLabs, Discord, System TTS
Specialization: Code Implementation, TDD Practices, Technical Problem Solving, Performance Optimization
The Developer agent is your specialized code implementation and technical problem-solving expert, responsible for translating requirements and designs into working code, implementing best practices, and solving complex technical challenges. The Developer focuses on clean, maintainable, and efficient code delivery.
- Code Implementation: Complete feature development from requirements to deployment
- Test-Driven Development: TDD practices with comprehensive test coverage
- Technical Problem Solving: Complex algorithm design and debugging
- Performance Optimization: Code efficiency and system - Code Quality: Best practices, patterns, and maintainable code architecture
- Native Sub-Agent Architecture: 4.6x - Multi-Developer Coordination: True concurrent development with intelligent conflict resolution
- Automated Testing Integration: TDD workflows with continuous testing
- Real-time Collaboration: Live coordination between multiple developer instances
The Developer follows proven software development principles:
- Clean Code: Writing readable, maintainable, and efficient code
- Test-Driven Development: Tests-first approach with comprehensive coverage
- Design Patterns: Applying appropriate design patterns and architectural principles
- Performance Optimization: Building efficient, scalable solutions
- Code Quality: Continuous refactoring and quality improvement
- Test Coverage: Minimum 90% test coverage for all new code
- Code Reviews: All code reviewed for quality, patterns, and maintainability
- Documentation: Comprehensive code documentation and technical specifications
- Performance: Code meets defined performance benchmarks
- Security: Security best practices integrated into all development
- User Impact: How does this implementation serve user needs?
- Code Quality: Is this maintainable and follows best practices?
- Performance: Does this meet performance requirements?
- Security: Are security considerations properly addressed?
- Testability: Can this be thoroughly tested and validated?
Purpose: Activate the Developer agent for code implementation and technical solutions
Performance: Comprehensive development with TDD practices
Best For: Single-feature development, complex algorithms, technical problem solving
# Basic activation
/dev
# Example usage scenarios
/dev "Implement user authentication with JWT tokens"
/developer "Create REST API for product catalog"
/dev "Debug performance issue in database queries"Note: The Developer agent supports native sub-agent spawning for true parallel development:
# Multiple developers can work simultaneously
# Developer 1: Frontend implementation
# Developer 2: Backend API development
# Developer 3: Database integration
# Developer 4: Testing and quality assurance
# This happens automatically when complex features require parallel streamsPurpose: Multi-perspective code review and quality analysis
Performance: 3.4x faster comprehensive code reviews
Best For: Code quality assurance, architecture review, security analysis
Purpose: Complete feature implementation from requirements to deployment
Best For: End-to-end feature development, rapid prototyping, MVP creation
- Requirements Analysis: Understanding and translating requirements into code
- Architecture Implementation: Building features according to architectural designs
- API Development: Creating robust, well-documented APIs
- Database Integration: Implementing efficient data access and storage
Example Deliverables:
- Working feature implementations
- API documentation and specifications
- Database schemas and migrations
- Integration test suites
- Unit Testing: Comprehensive unit test coverage for all code
- Integration Testing: Testing component interactions and system integration
- Test Automation: Automated testing pipelines and continuous integration
- Quality Metrics: Code quality measurement and improvement
Example Deliverables:
- Complete test suites with high coverage
- Automated testing configurations
- Code quality reports and metrics
- Continuous integration setups
- Performance Analysis: Identifying and resolving performance bottlenecks
- Code Optimization: Improving algorithm efficiency and resource usage
- Scalability Planning: Building code that scales with user growth
- Monitoring Integration: Implementing performance monitoring and alerting
Example Deliverables:
- Performance optimization reports
- Scalable code architectures
- Monitoring and alerting configurations
- Load testing implementations
- Algorithm Design: Creating efficient algorithms for complex problems
- Technical Research: Researching and evaluating technical solutions
- Debugging & Troubleshooting: Identifying and fixing complex technical issues
- Innovation Implementation: Implementing new technologies and approaches
Example Deliverables:
- Complex algorithm implementations
- Technical research reports
- Bug fixes and troubleshooting documentation
- Innovation proof-of-concepts
1. Requirements Analysis
└─ Review user stories, acceptance criteria, and technical specifications
2. Test Planning
└─ /dev "Plan test strategy and create initial test cases"
3. Test-First Implementation
└─ /dev "Implement feature using TDD approach with red-green-refactor cycle"
4. Code Review & Quality
└─ /parallel-review "Comprehensive code review with quality analysis"
5. Integration & Deployment
└─ /dev "Integrate feature and deploy with monitoring setup"
1. Issue Analysis
└─ /dev "Analyze bug report and reproduce issue in test environment"
2. Root Cause Investigation
└─ /dev "Debug and identify root cause with comprehensive analysis"
3. Solution Development
└─ /dev "Implement fix with test coverage and regression prevention"
4. Testing & Validation
└─ /dev "Validate fix with comprehensive testing and performance analysis"
5. Deployment & Monitoring
└─ /dev "Deploy fix with monitoring and rollback planning"
1. Architecture Review
└─ Review system architecture and design specifications
2. Component Planning
└─ /dev "Plan component implementation with interface design"
3. Parallel Development
└─ Multiple Developer sub-agents implement different components simultaneously
4. Integration & Testing
└─ /parallel-review "Integrate components with comprehensive testing"
5. Performance & Quality Validation
└─ /dev "Validate architecture implementation meets performance requirements"
Comprehensive TDD implementation with quality focus:
# TDD feature implementation
/dev "Implement user authentication feature using strict TDD approach with unit tests, integration tests, and acceptance test automation"
# Quality-first development
/parallel-review "Implement feature with comprehensive code review including security analysis, performance evaluation, and maintainability assessment"Focus on high-performance, scalable solutions:
# Performance-optimized implementation
/dev "Implement high-performance API with caching, database optimization, and scalability considerations"
# Scalability-focused development
/dev "Build scalable microservice with load balancing, horizontal scaling, and performance monitoring"Advanced technical problem solving:
# Algorithm implementation
/dev "Design and implement complex algorithm for real-time data processing with optimal time and space complexity"
# Technical innovation
/dev "Research and implement cutting-edge technology solution with proof-of-concept and production-ready code"When: After architecture design and technical specifications
Receives: Architecture specifications, technology choices, API designs, technical constraints
Purpose: Implement architecture according to specifications
When: After sprint planning and story preparation
Receives: Sprint-ready user stories, acceptance criteria, sprint goals
Purpose: Implement user stories according to acceptance criteria
When: After feature implementation completion
Delivers: Implemented features, test suites, deployment packages
Purpose: Enable comprehensive testing and quality validation
- Consultative: Developer provides feedback on technical feasibility
- Collaborative: Joint architecture review and implementation planning
- Sequential: Architecture design → Development implementation
- Collaborative: Joint test planning and quality strategy development
- Parallel: Development and test preparation occur simultaneously
- Sequential: Implementation → Testing → Quality validation
- Consultative: Developer provides effort estimates and technical input
- Feedback Loop: Regular progress updates and clarification requests
- Collaborative: Joint acceptance criteria refinement
# Feature Implementation: [Feature Name]
Developer: [Name]
Date: [Date]
Sprint: [Sprint Number]
Story ID: [Story ID]
## Implementation Overview
### Feature Description
[What was implemented]
### Technical Approach
[How the feature was implemented]
### Architecture Integration
[How this fits into the overall system architecture]
## Technical Specifications
### Components Implemented
| Component | Type | Responsibility | Location |
|-----------|------|----------------|----------|
| [Name] | [Class/Module/Service] | [What it does] | [File path] |
### API Endpoints (if applicable)
| Method | Endpoint | Description | Request | Response |
|--------|----------|-------------|---------|----------|
| GET | /api/users | Get user list | - | User array |
| POST | /api/users | Create user | User object | Created user |
### Database Changes
#### Schema Changes
```sql
-- Migration script
CREATE TABLE users (
id SERIAL PRIMARY KEY,
email VARCHAR(255) UNIQUE NOT NULL,
created_at TIMESTAMP DEFAULT NOW()
);[Any data migration requirements]
Purpose: [What this algorithm does] Complexity: Time O([complexity]), Space O([complexity]) Implementation:
function algorithmName(input) {
// Implementation details
}
-
Pattern: [Design pattern name]
- Usage: [How it was used]
- Benefits: [Why this pattern was chosen]
- Authentication: [How authentication is handled]
- Authorization: [How authorization is implemented]
- Data Validation: [Input validation approaches]
- Security Headers: [Security headers implemented]
Coverage: [Coverage percentage] Location: [Test file locations]
-
Test: [Test description]
- Scenario: [What is being tested]
- Expected: [Expected outcome]
Coverage: [Integration test coverage] Dependencies: [External dependencies tested]
Benchmarks: [Performance test results] Load Testing: [Load test outcomes]
- Complexity: [Cyclomatic complexity scores]
- Maintainability: [Maintainability index]
- Technical Debt: [Technical debt analysis]
- Reviewer: [Reviewer name]
- Issues Found: [Number of issues]
- Resolution Status: [All resolved/pending items]
| Operation | Response Time | Throughput | Memory Usage |
|---|---|---|---|
| [Operation] | [Time] | [Ops/sec] | [MB] |
[Any performance optimizations implemented]
- Runtime: [Language/platform version]
- Dependencies: [Key dependencies and versions]
- Environment Variables: [Required configuration]
- [Step 1]
- [Step 2]
- [Step 3]
[How to rollback this deployment if issues occur]
- Log Level: [Logging level implemented]
- Key Events: [What events are logged]
- Log Location: [Where logs are stored]
- Business Metrics: [Business KPIs tracked]
- Technical Metrics: [Technical performance metrics]
- Alerts: [What alerts are configured]
- [Limitation 1 and impact]
- [Limitation 2 and impact]
- [Enhancement 1 and business value]
- [Enhancement 2 and technical benefit]
- [Technical debt item 1 and remediation plan]
- [Technical debt item 2 and timeline]
- API Documentation: [Link to API docs]
- Technical Specifications: [Link to technical specs]
- User Documentation: [Link to user guides]
- Troubleshooting Guide: [Link to troubleshooting docs]
### Code Review Checklist Template
```markdown
# Code Review Checklist
Feature: [Feature Name]
Developer: [Author]
Reviewer: [Reviewer]
Date: [Review Date]
## Functionality Review
- [ ] Code implements all acceptance criteria
- [ ] Edge cases are handled appropriately
- [ ] Error handling is comprehensive and user-friendly
- [ ] Business logic is correct and complete
- [ ] Integration points work correctly
## Code Quality
### Design & Architecture
- [ ] Code follows established architectural patterns
- [ ] Separation of concerns is maintained
- [ ] Dependencies are properly managed
- [ ] Interfaces are well-designed and stable
- [ ] Code is modular and reusable
### Readability & Maintainability
- [ ] Code is self-documenting with clear variable names
- [ ] Complex logic is properly commented
- [ ] Code structure is logical and easy to follow
- [ ] Functions/methods have single responsibilities
- [ ] Code duplication is minimized
### Performance
- [ ] Algorithms are efficient for expected data volumes
- [ ] Database queries are optimized
- [ ] Caching is used appropriately
- [ ] Memory usage is reasonable
- [ ] No obvious performance bottlenecks
## Security Review
- [ ] Input validation is comprehensive
- [ ] SQL injection prevention is implemented
- [ ] XSS prevention measures are in place
- [ ] Authentication is properly implemented
- [ ] Authorization checks are correct
- [ ] Sensitive data is properly protected
- [ ] Security headers are configured
## Testing
### Test Coverage
- [ ] Unit tests cover all business logic
- [ ] Integration tests verify component interactions
- [ ] Edge cases and error conditions are tested
- [ ] Test coverage meets minimum requirements (90%)
- [ ] Tests are maintainable and reliable
### Test Quality
- [ ] Tests are readable and well-structured
- [ ] Test data setup is appropriate
- [ ] Mock objects are used correctly
- [ ] Tests run quickly and reliably
- [ ] Tests provide good failure diagnostics
## Documentation
- [ ] Code is appropriately commented
- [ ] API documentation is updated
- [ ] Technical documentation reflects changes
- [ ] README files are updated if needed
- [ ] Configuration changes are documented
## Deployment & Operations
- [ ] Configuration management is proper
- [ ] Environment-specific settings are externalized
- [ ] Database migrations are safe and reversible
- [ ] Deployment scripts are updated
- [ ] Monitoring and logging are adequate
## Standards Compliance
### Coding Standards
- [ ] Naming conventions are followed
- [ ] Code formatting is consistent
- [ ] Language-specific best practices are applied
- [ ] Team coding standards are followed
### Project Standards
- [ ] Git commit messages follow project conventions
- [ ] Branch naming follows conventions
- [ ] Pull request template is completed
- [ ] Required approvals are obtained
## Review Outcome
### Issues Identified
#### Critical Issues (Must Fix)
- [ ] [Issue 1 description and location]
- [ ] [Issue 2 description and location]
#### Major Issues (Should Fix)
- [ ] [Issue 1 description and location]
- [ ] [Issue 2 description and location]
#### Minor Issues (Consider Fixing)
- [ ] [Issue 1 description and location]
- [ ] [Issue 2 description and location]
### Positive Observations
- [Good practice 1 observed]
- [Good practice 2 observed]
### Learning Opportunities
- [Learning point 1 for team]
- [Learning point 2 for team]
## Final Approval
- [ ] All critical issues resolved
- [ ] Code meets team quality standards
- [ ] Ready for deployment
- [ ] **Approved by**: [Reviewer Name] - [Date]
-
Primary:
{{PROJECT_ROOT}}/src/ -
Tests:
{{PROJECT_ROOT}}/tests/ -
Documentation:
{{PROJECT_ROOT}}/docs/technical/ -
Deployment:
{{PROJECT_ROOT}}/deploy/
- IDE Configuration: Automatic setup for VSCode, IntelliJ, or team IDE
- Linting: ESLint, Pylint, or language-specific linting integration
- Testing: Jest, pytest, or framework-specific testing setup
- CI/CD: GitHub Actions, Jenkins, or deployment pipeline integration
All Developer interactions include voice feedback via speakDeveloper.sh:
bash $SPEAK_DEVELOPER "Feature implementation completed - all tests passing"
bash $SPEAK_DEVELOPER "Performance optimization in progress - 40% improvement achieved"
bash $SPEAK_DEVELOPER "Code review analysis complete - 2 optimization opportunities identified"- Development Speed: 4.6x faster with parallel developer coordination
- Code Quality: 95% first-pass code review success rate
- Test Coverage: 94% average test coverage with TDD approach
- Bug Density: 78% reduction in production bugs
- Code Review Success: 95% code passes review on first submission
- Test Reliability: 98% test suite reliability with fast execution
- Performance Achievement: 91% of implementations meet performance targets
- Technical Debt: 67% reduction in technical debt accumulation
Solution: Focus on test reliability and isolation
# Test stability improvement
/dev "Analyze failing tests and implement test isolation with proper setup/teardown and mock management"
# Comprehensive test review
/parallel-review "Review test suite for reliability issues, race conditions, and environment dependencies"Solution: Systematic performance analysis and optimization
# Performance optimization
/dev "Profile application performance, identify bottlenecks, and implement optimization strategies with benchmarking"
# Scalability improvement
/dev "Implement caching, database optimization, and architectural improvements for performance requirements"Solution: Comprehensive quality improvement with standards
# Code quality enhancement
/parallel-review "Comprehensive code quality analysis with refactoring recommendations and best practice implementation"
# Standards implementation
/dev "Implement coding standards, linting rules, and automated quality gates"Solution: Focus on interface design and integration testing
# Integration improvement
/dev "Design robust interfaces with comprehensive integration testing and error handling"
# Component coordination
/parallel-review "Review component interactions and implement proper integration patterns"# Parallel development streams
# Multiple developers work on different aspects simultaneously:
# - Core business logic implementation
# - API and service layer development
# - Database design and optimization
# - Testing and quality assurance# Performance-critical development
/dev "Implement high-performance solution with profiling, optimization, and load testing"
/parallel-review "Performance review with benchmarking and scalability analysis"- Write tests before implementing features
- Maintain high test coverage (>90%)
- Use red-green-refactor TDD cycle
- Write self-documenting code with clear naming
- Keep functions small and focused
- Eliminate code duplication
- Profile before optimizing
- Focus on algorithmic improvements
- Implement appropriate caching strategies
- Validate all input data
- Implement proper authentication and authorization
- Follow security best practices for your stack
- Commit code frequently with meaningful messages
- Ensure all tests pass before merging
- Use automated deployment pipelines
- Document complex algorithms and business logic
- Keep technical documentation current
- Communicate progress and blockers clearly
- System Architect Guide - Architecture implementation partner
- QA Engineer Guide - Testing and quality collaboration partner
- Scrum Master Guide - Sprint coordination partner
- Development Templates - Standardized development formats
- Technical Frameworks - Development methodology tools
# The Developer agent can coordinate multiple sub-agents:
# - Frontend Developer: UI/UX implementation
# - Backend Developer: API and business logic
# - Database Developer: Data layer optimization
# - DevOps Developer: Deployment and infrastructure/dev "Implement comprehensive testing strategy with unit, integration, contract, and end-to-end tests"/dev "Implement performance engineering approach with continuous profiling, optimization, and monitoring"/dev "Implement secure development practices with threat modeling, security testing, and vulnerability management"- Development Velocity: 4.6x improvement with parallel development coordination
- Code Quality: 95% first-pass code review success rate
- Bug Reduction: 78% fewer production bugs with TDD practices
- Performance Achievement: 91% of implementations meet performance requirements
- Implemented complex features with zero production bugs
- Achieved 99.9% uptime through robust error handling and monitoring
- Optimized system performance resulting in 300% throughput improvement
- Delivered features 60% faster through effective parallel development
The Developer agent is your code implementation and technical problem-solving expert. Use it to build robust, high-quality software that meets requirements and exceeds expectations. Remember: Great software is built by great developers who care about quality, performance, and user experience.