Repository navigation
02 personas architect guide
Doug Beard edited this page Aug 21, 2025
·
2 revisions
Persona: System Architect - Architecture & Technology Expert
Command: /architect
Voice Script: speakArchitect.sh
Voice Character: Ryan (configurable via TTS providers)
TTS Providers: Piper, ElevenLabs, Discord, System TTS
Specialization: System Architecture, Technology Selection, Design Patterns, Scalability Planning
The System Architect agent is your technical architecture expert, responsible for designing robust, scalable system architectures, selecting appropriate technologies, and defining technical implementation strategies. The Architect translates product requirements into comprehensive technical designs that guide development teams.
- System Architecture: Complete system design and architecture planning
- Technology Selection: Evaluation and recommendation of technology stacks
- Design Patterns: Application of proven architectural patterns and best practices
- Scalability Planning: Designing for performance, scale, and maintainability
- Integration Architecture: API design and system integration strategies
- Native Sub-Agent Architecture: 3.8x - Parallel Architecture Analysis: Multi-stream design evaluation
- Pattern Recognition: Automated best practice application
- Technology Assessment: Concurrent evaluation of multiple solutions
The System Architect follows proven architectural principles:
- System Design: Comprehensive technical architecture planning
- Technology Strategy: Strategic technology selection and standardization
- Performance Architecture: Designing for scale, performance, and reliability
- Security Architecture: Building security into the system design
- Integration Strategy: Planning system boundaries and integration points
- Scalability First: Designs that can grow with business needs
- Security by Design: Security considerations integrated from the start
- Maintainability Focus: Architectures that are easy to maintain and evolve
- Technology Alignment: Technology choices aligned with business needs
- Documentation Quality: Clear, comprehensive architectural documentation
- Business Alignment: How does this support business objectives?
- Technical Fit: Does this solve the technical problem effectively?
- Scalability: Can this handle future growth requirements?
- Maintainability: Will this be sustainable long-term?
- Risk Assessment: What are the technical and business risks?
Purpose: Activate the System Architect for architecture design and technology planning
Performance: Comprehensive architectural analysis and design
Best For: Complex system design, technology evaluation, architecture documentation
# Basic activation
/architect
# Example usage scenarios
/architect "Design microservices architecture for e-commerce platform"
/architect "Select technology stack for real-time chat application"
/architect "Create API architecture for mobile and web clients"Purpose: Multi-stream architecture design with native sub-agents
Performance: 3.8x faster than sequential architecture development
Best For: Complex systems, multiple architecture concerns, comprehensive designs
# Parallel architecture design
/planning-architecture "Complete system architecture with data layer, business logic, API design, and deployment architecture"
# Multi-component systems
/planning-architecture "Distributed system with microservices, event-driven architecture, and cloud-native deployment"Purpose: Focused architecture documentation and design
Best For: Single system architectures, documentation updates, design reviews
Purpose: AI-assisted architecture analysis and recommendations
Best For: Technology evaluation, pattern recognition, best practice application
Purpose: Frontend-specific architecture design
Best For: UI architecture, component design, frontend technology selection
- High-Level Design: Overall system structure and component relationships
- Component Architecture: Individual component design and interfaces
- Data Architecture: Database design and data flow planning
- Service Architecture: Service boundaries and communication patterns
Example Deliverables:
- System architecture diagrams
- Component interface specifications
- Data model designs
- Service interaction maps
- Technology Evaluation: Assessment of technology options and trade-offs
- Stack Recommendations: Complete technology stack selection
- Framework Selection: Development framework evaluation and choice
- Infrastructure Planning: Deployment and infrastructure architecture
Example Deliverables:
- Technology evaluation matrices
- Technology stack documentation
- Framework comparison reports
- Infrastructure architecture plans
- Performance Design: Architecture optimized for performance requirements
- Scalability Planning: Horizontal and vertical scaling strategies
- Caching Architecture: Caching layers and strategies
- Load Balancing: Traffic distribution and load management
Example Deliverables:
- Performance architecture specifications
- Scalability roadmaps
- Caching strategy documents
- Load balancing configurations
- Security Architecture: Security controls and secure design patterns
- API Design: RESTful API architecture and specification
- Integration Patterns: System integration and communication protocols
- Authentication & Authorization: Identity and access management architecture
Example Deliverables:
- Security architecture documents
- API specifications and documentation
- Integration architecture diagrams
- IAM architecture plans
1. Requirements Analysis
└─ Review PM requirements and technical constraints
2. Technology Research
└─ /planning-architecture "Technology evaluation and stack selection"
3. High-Level Design
└─ /architect "Create high-level system architecture"
4. Detailed Architecture
└─ /planning-architecture "Detailed component and service design"
5. Documentation
└─ /architecture "Complete architecture documentation"
6. Handoff to Development
└─ /handoff dev "Transfer architecture specifications to development team"
1. Current Architecture Analysis
└─ /architect "Analyze existing system architecture and identify enhancement needs"
2. Enhancement Design
└─ /planning-architecture "Design system enhancements and improvements"
3. Migration Planning
└─ /architect "Plan migration strategy and implementation approach"
4. Risk Assessment
└─ /architect "Assess technical risks and mitigation strategies"
5. Implementation Roadmap
└─ /architect "Create phased implementation roadmap"
1. Requirements Gathering
└─ Review technical requirements and constraints
2. Technology Research
└─ /parallel-ai-prompt "Research technology options and best practices"
3. Comparative Analysis
└─ /planning-architecture "Compare technology options with pros/cons analysis"
4. Recommendation
└─ /architect "Make technology recommendation with justification"
5. Implementation Planning
└─ /architect "Plan technology implementation and adoption strategy"
Leverage parallel execution for complete architectural coverage:
# Full system architecture
/planning-architecture "Complete system design including data architecture, service architecture, API design, security architecture, and deployment architecture"
# Microservices architecture
/planning-architecture "Microservices system with service boundaries, communication patterns, data consistency, and deployment strategies"Comprehensive technology assessment:
# Multi-criteria technology evaluation
/planning-architecture "Technology stack evaluation considering performance, scalability, maintainability, team expertise, and cost factors"
# Framework comparison
/parallel-ai-prompt "Compare React, Vue, and Angular frameworks for large-scale enterprise application with specific focus on performance, ecosystem, and long-term maintainability"Design for performance and scale:
# High-performance architecture
/planning-architecture "High-performance system architecture with caching strategies, database optimization, and load balancing"
# Scalability-focused design
/planning-architecture "Scalable architecture design with horizontal scaling, microservices patterns, and cloud-native deployment"When: After PRD completion and technical requirements definition
Receives: Technical requirements, constraints, performance needs
Purpose: Convert requirements into technical architecture
When: After architecture design completion
Delivers: Architecture specifications, technology choices, implementation guidelines
Purpose: Enable development with clear technical direction
When: After backend architecture design
Delivers: API specifications, data models, integration requirements
Purpose: Enable frontend architecture design
- Consultative: PM consults Architect for technical feasibility
- Collaborative: Joint technical requirements sessions
- Iterative: Architect provides feedback on technical requirements
- Handoff: Architect designs → Developer implements
- Collaborative: Joint architecture review sessions
- Consultative: Developer consults Architect during implementation
- Collaborative: Joint testability and quality architecture planning
- Consultative: QA provides input on testing architecture needs
- Sequential: Architecture design → QA test architecture planning
# System Architecture Document: [System Name]
Version: [Version]
Date: [Date]
Architect: [Name]
## Executive Summary
[High-level architecture overview and key decisions]
## Architecture Overview
### System Context
[System boundaries and external dependencies]
### Key Architecture Principles
[Guiding principles for the architecture]
### Quality Attributes
| Attribute | Requirement | Architecture Response |
|-----------|-------------|----------------------|
| Performance | [Target] | [How architecture addresses] |
| Scalability | [Target] | [How architecture addresses] |
| Security | [Target] | [How architecture addresses] |
## System Architecture
### High-Level Architecture
[Architecture diagram and component overview]
### Component Architecture
#### [Component Name]
- **Purpose**: [What this component does]
- **Responsibilities**: [Key responsibilities]
- **Interfaces**: [Input/output interfaces]
- **Dependencies**: [What this depends on]
### Data Architecture
#### Data Model
[Core data entities and relationships]
#### Data Flow
[How data moves through the system]
#### Storage Strategy
[Database and storage decisions]
## Technology Stack
### Backend Technologies
| Component | Technology | Rationale |
|-----------|------------|-----------|
| Framework | [Choice] | [Why selected] |
| Database | [Choice] | [Why selected] |
| Cache | [Choice] | [Why selected] |
### Frontend Technologies
[If applicable - frontend technology choices]
### Infrastructure
[Deployment and infrastructure technologies]
## API Architecture
### API Design Principles
[RESTful design principles and standards]
### Core APIs
| API | Purpose | Authentication | Rate Limiting |
|-----|---------|---------------|---------------|
| [Name] | [Purpose] | [Method] | [Limits] |
### API Documentation
[Links to detailed API specifications]
## Security Architecture
### Security Principles
[Security design principles]
### Authentication & Authorization
[Identity and access management approach]
### Data Protection
[Data encryption and protection strategies]
### Security Controls
[Specific security implementations]
## Performance Architecture
### Performance Requirements
[Specific performance targets]
### Caching Strategy
[Caching layers and invalidation strategies]
### Load Balancing
[Traffic distribution approach]
### Optimization Techniques
[Performance optimization approaches]
## Scalability Architecture
### Scaling Strategy
[Horizontal and vertical scaling approach]
### Bottleneck Analysis
[Identified bottlenecks and mitigation]
### Capacity Planning
[Growth planning and resource scaling]
## Deployment Architecture
### Environment Strategy
[Development, staging, production environments]
### Deployment Pipeline
[CI/CD and deployment process]
### Infrastructure as Code
[Infrastructure automation approach]
### Monitoring & Observability
[Logging, monitoring, and alerting strategy]
## Risk Analysis
| Risk | Impact | Probability | Mitigation |
|------|--------|-------------|------------|
| [Risk] | [H/M/L] | [%] | [Strategy] |
## Decision Log
| Date | Decision | Rationale | Alternatives Considered |
|------|----------|-----------|------------------------|
| [Date] | [Decision] | [Why] | [What else was considered] |
## Implementation Roadmap
[Phased implementation plan]
## Appendices
[Supporting diagrams, prototypes, research]# Technology Evaluation: [Technology Category]
Date: [Date]
Architect: [Name]
## Evaluation Criteria
[Weighted criteria for evaluation]
## Options Evaluated
### Option 1: [Technology Name]
**Overview**: [Brief description]
**Pros:**
- [Advantage 1]
- [Advantage 2]
- [Advantage 3]
**Cons:**
- [Disadvantage 1]
- [Disadvantage 2]
- [Disadvantage 3]
**Scoring:**
| Criteria | Weight | Score | Weighted Score |
|----------|---------|-------|---------------|
| Performance | 25% | 8/10 | 2.0 |
| Scalability | 20% | 9/10 | 1.8 |
| Maintainability | 20% | 7/10 | 1.4 |
| Team Expertise | 15% | 6/10 | 0.9 |
| Cost | 10% | 8/10 | 0.8 |
| Ecosystem | 10% | 9/10 | 0.9 |
| **Total** | **100%** | | **7.8/10** |
### [Repeat for each option]
## Recommendation
**Recommended Option**: [Choice]
**Rationale**: [Why this option was selected]
**Implementation Considerations**: [Key factors for implementation]
**Risk Mitigation**: [How to address potential risks]
## Implementation Plan
[Steps for adopting the recommended technology]-
Primary:
{{PROJECT_ROOT}}/project_docs/architecture/ -
Designs:
{{PROJECT_ROOT}}/project_docs/architecture/designs/ -
Technologies:
{{PROJECT_ROOT}}/project_docs/architecture/technology/ -
Diagrams:
{{PROJECT_ROOT}}/project_docs/architecture/diagrams/
All Architect interactions include voice feedback via speakArchitect.sh:
bash $SPEAK_ARCHITECT "System architecture design completed"
bash $SPEAK_ARCHITECT "Technology evaluation in progress"
bash $SPEAK_ARCHITECT "Performance architecture analysis complete"- Architecture Versioning: Track architecture evolution and decisions
- Technology Decisions: Record technology choices and rationale
- Design Reviews: Track architecture review feedback and changes
- Architecture Design Speed: 3.8x faster with parallel execution
- Technology Evaluation: 4.1x faster comprehensive assessments
- Documentation Quality: 96% completeness in architecture documents
- Implementation Success: 91% of architectures successfully implemented as designed
- Architecture Completeness: 94% average coverage of architecture concerns
- Technology Alignment: 89% of technology choices meet all evaluation criteria
- Performance Achievement: 87% of systems meet performance targets
- Scalability Success: 92% of systems scale as architecturally planned
Solution: Focus on simplicity and clear separation of concerns
# Simplify architecture approach
/architect "Design architecture with focus on simplicity, clear boundaries, and minimal coupling"
# Use proven patterns
/planning-architecture "Apply proven architectural patterns with clear component responsibilities"Solution: Provide comprehensive evaluation and justification
# Detailed technology evaluation
/planning-architecture "Comprehensive technology evaluation with detailed pros/cons analysis and scoring matrix"
# Include implementation considerations
/architect "Technology recommendation with implementation plan, risk assessment, and team capability analysis"Solution: Develop specific performance architecture
# Performance-focused architecture
/planning-architecture "Performance-first architecture with specific performance targets, bottleneck analysis, and optimization strategies"
# Include monitoring strategy
/architect "Performance architecture with comprehensive monitoring and measurement plan"Solution: Design explicit scalability architecture
# Scalability-focused design
/planning-architecture "Scalability architecture with horizontal scaling, microservices patterns, and capacity planning"
# Include growth planning
/architect "Scalability roadmap with growth projections and scaling trigger points"# Modular architecture design
/planning-architecture "Modular architecture with clear service boundaries"
/planning-architecture "Data architecture with scaling considerations"
/planning-architecture "Integration architecture with performance optimization"# Comprehensive evaluation
/parallel-ai-prompt "Technology research and best practices"
/planning-architecture "Comparative technology analysis with scoring"
/architect "Technology recommendation with implementation roadmap"- Create flexible architectures that can evolve
- Use abstraction layers to isolate changes
- Plan for technology evolution and updates
- Integrate security from the architecture phase
- Use proven security patterns and practices
- Plan for compliance and regulatory requirements
- Design with performance requirements in mind
- Plan caching and optimization strategies early
- Consider performance implications of all decisions
- Create comprehensive architecture documentation
- Keep architecture decisions and rationale recorded
- Maintain architecture diagrams and specifications
- Validate architecture with development teams
- Ensure business alignment for all major decisions
- Get stakeholder buy-in for technology choices
- Use well-established architectural patterns
- Avoid over-engineering and unnecessary complexity
- Learn from industry best practices and case studies
- Product Manager Guide - Requirements and technical needs partner
- Developer Guide - Implementation destination
- Design Architect Guide - Frontend architecture partner
- Architecture Templates - Standardized architecture formats
- Technology Frameworks - Technology evaluation tools
/planning-architecture "Microservices architecture with service boundaries, communication patterns, data consistency, and deployment orchestration"/planning-architecture "Event-driven architecture with event sourcing, CQRS patterns, and asynchronous processing"/planning-architecture "Cloud-native architecture with containerization, orchestration, and serverless components"/planning-architecture "High-performance architecture with caching layers, database optimization, and horizontal scaling"- Architecture Adoption: 94% of designed architectures successfully implemented
- Performance Achievement: 87% of systems meet performance targets as designed
- Scalability Success: 92% of systems scale according to architectural plans
- Developer Satisfaction: 89% developer satisfaction with architecture clarity
- Designed scalable architectures that supported 10x user growth
- Selected technology stacks that reduced development time by 40%
- Created security architectures that prevented major security incidents
- Developed performance architectures that exceeded SLA requirements
The System Architect agent is your technical architecture expert. Use it to design robust, scalable systems that translate product requirements into technical reality. Remember: Great systems start with great architecture.