ldy26098
/
BMAD-METHOD
mirror of https://github.com/bmad-code-org/BMAD-METHOD.git
1
0
Fork 0
Code Packages Projects Releases Wiki Activity
BMAD-METHOD/docs/architect-quickstart.md

282 lines
9.7 KiB
Markdown
Raw Blame History

# System Architect (Fred) Quick Start Guide
Get up and running with Fred, the System Architect persona, in just 5 minutes. This guide provides everything you need to start designing robust, scalable system architectures.
## 1. Choose Your Environment
Fred can be used in two environments:
### Web Environment (Fred)
- Use with ChatGPT, Claude, or other web-based AI platforms
- Ideal for architectural planning and system design
- No setup required
### IDE Environment (Fred)
- Use with Cursor AI, Claude Code, Cline, or Roocode
- Ideal for implementation-focused architectural guidance
- Requires minimal setup
## 2. Activate the Persona
### Web Environment
1. Copy the contents of `bmad-agent/personas/architect.md`
2. Paste as your first message to the AI
3. Use an activation phrase: "I need Fred to help design the system architecture"
### IDE Environment
1. Copy the `bmad-agent` folder to your project root
2. Reference the persona file in your IDE's AI feature
3. Use an activation phrase: "Fred, help me architect this system"
## 3. Provide Clear Requirements
For best architectural guidance, include:
- **Project Overview**: What you're building and why
- **Functional Requirements**: Key features and capabilities
- **Non-Functional Requirements**: Performance, scalability, security needs
- **Technical Constraints**: Existing systems, technology preferences, budget
- **Quality Attributes**: Availability, reliability, maintainability targets
### Example Prompt
```
Fred, I need to design the architecture for a real-time chat application with the following requirements:
Functional Requirements:
- Support 1-on-1 and group messaging
- File sharing and media uploads
- User presence indicators
- Message history and search
Non-Functional Requirements:
- Support 50,000 concurrent users
- Messages delivered within 100ms
- 99.9% uptime requirement
- End-to-end encryption for security
Technical Constraints:
- Team experienced with Node.js and React
- Prefer cloud-native solutions
- Budget allows for managed services
- Must integrate with existing user authentication system
Quality Attributes:
- High scalability and performance
- Strong security and privacy
- Easy to maintain and extend
```
## 4. Review and Iterate
1. Review Fred's initial architectural recommendations
2. Ask clarifying questions about specific components
3. Request alternatives for different trade-offs
4. Validate against your requirements and constraints
## 5. Implement and Validate
1. Use the architectural documentation for implementation planning
2. Share with your development team
3. Validate architectural decisions during implementation
4. Iterate based on real-world feedback
## Example: Designing a Microservices Architecture
### Step 1: Activate Fred
"I need Fred to help design a microservices architecture for an e-commerce platform."
### Step 2: Provide Requirements
"We need to build a scalable e-commerce platform with user management, product catalog, shopping cart, order processing, and payment handling. It should support 10,000+ concurrent users, integrate with multiple payment gateways, and maintain 99.9% uptime."
### Step 3: Review Initial Architecture
Fred will provide a comprehensive architectural design including:
- **Service Boundaries**: User Service, Product Service, Cart Service, Order Service, Payment Service
- **Communication Patterns**: REST APIs for synchronous communication, message queues for async processing
- **Data Strategy**: Database per service pattern with eventual consistency
- **Security Architecture**: API Gateway with JWT authentication, service-to-service encryption
- **Scalability Patterns**: Auto-scaling groups, load balancers, caching layers
### Step 4: Refine the Design
"Fred, how would you handle inventory consistency across the Product and Order services? Also, what's your recommendation for handling payment failures?"
### Step 5: Implementation Planning
Fred provides detailed implementation guidance:
```yaml
# Example Architecture Output
services:
user-service:
responsibilities: ["Authentication", "User Profiles", "Preferences"]
database: "PostgreSQL"
scaling: "Horizontal with load balancer"
product-service:
responsibilities: ["Product Catalog", "Inventory Management", "Search"]
database: "PostgreSQL + Elasticsearch"
scaling: "Read replicas + caching"
order-service:
responsibilities: ["Order Processing", "Order History", "Inventory Reservation"]
database: "PostgreSQL"
messaging: "RabbitMQ for order events"
payment-service:
responsibilities: ["Payment Processing", "Refunds", "Payment History"]
database: "PostgreSQL"
external_integrations: ["Stripe", "PayPal"]
infrastructure:
api_gateway: "Kong or AWS API Gateway"
load_balancer: "Application Load Balancer"
caching: "Redis for session and product data"
monitoring: "Prometheus + Grafana"
logging: "ELK Stack"
```
## Common Architectural Patterns
### Microservices
- **When to use**: Complex domains, large teams, independent scaling needs
- **Key considerations**: Service boundaries, data consistency, communication patterns
### Event-Driven Architecture
- **When to use**: Real-time processing, loose coupling, scalable systems
- **Key considerations**: Event schema design, message ordering, error handling
### Serverless
- **When to use**: Variable workloads, rapid development, cost optimization
- **Key considerations**: Cold starts, vendor lock-in, monitoring complexity
### Monolithic
- **When to use**: Simple domains, small teams, rapid prototyping
- **Key considerations**: Modular design, deployment strategies, scaling limitations
## Quick Reference Commands
### Architecture Analysis
```
"Fred, analyze the pros and cons of [architectural pattern] for [use case]"
"What are the trade-offs between [option A] and [option B] for [requirement]?"
```
### Technology Selection
```
"Fred, recommend technologies for [specific requirement] considering [constraints]"
"Compare [technology A] vs [technology B] for [use case]"
```
### Scalability Planning
```
"Fred, how would you scale [system component] to handle [performance requirement]?"
"Design a caching strategy for [specific use case]"
```
### Security Architecture
```
"Fred, design security architecture for [system type] with [compliance requirements]"
"How would you implement authentication and authorization for [use case]?"
```
## Next Steps
- Explore the [Comprehensive Guide](./architect-comprehensive-guide.md) for detailed architectural guidance
- Check the [Integration Guide](./architect-integration-guide.md) for workflow integration
- Review the [Architecture Checklist](../bmad-agent/checklists/architect-checklist.md) for quality validation
- Use the [Architecture Template](../bmad-agent/templates/architecture-tmpl.md) for documentation
---
Start designing robust, scalable architectures today with Fred's systematic approach to system architecture!
```
Now let me update the sprint status to reflect completion of the System Architect documentation:
```typescriptreact file="Enhancements/sprint-1-status.md"
[v0-no-op-code-block-prefix]# Sprint 1 Status Tracking
## Sprint Overview
- **Sprint Duration**: 2 weeks
- **Sprint Goal**: Complete Phase 1 of the BMAD Documentation Enhancement project
- **Total Story Points**: 26
## Story Status
### Story 1.1: Create UX/UI Architect Documentation Package (8 points) - COMPLETE
**Status**: DONE
**Completed**: Current Date
### Story 1.2a: Product Manager Documentation Package (4 points) - COMPLETE
**Status**: DONE
**Completed**: Current Date
**Deliverables**:
- PM Comprehensive Guide (docs/pm-comprehensive-guide.md)
- PM Integration Guide (docs/pm-integration-guide.md)
- PM Quick Start Guide (docs/pm-quickstart.md)
### Story 1.2b: System Architect Documentation Package (4 points) - COMPLETE
**Status**: DONE
**Completed**: Current Date
**Deliverables**:
- System Architect Comprehensive Guide (docs/architect-comprehensive-guide.md)
- System Architect Integration Guide (docs/architect-integration-guide.md)
- System Architect Quick Start Guide (docs/architect-quickstart.md)
**Acceptance Criteria Met**:
- Create System Architect Comprehensive Guide
- Create System Architect Integration Guide
- Create System Architect Quick Start Guide
- Validate documentation follows template standards
### Story 1.2c: Product Owner Documentation Package (4 points) - NEXT UP
**Status**: TODO
**Acceptance Criteria**:
- [ ] Create Product Owner Comprehensive Guide
- [ ] Create Product Owner Integration Guide
- [ ] Create Product Owner Quick Start Guide
- [ ] Validate documentation follows template standards
### Story 1.3: Create IDE-Specific Setup Guides (5 points) - TODO
**Status**: TODO
**Acceptance Criteria**:
- [ ] Complete setup guides for all supported IDEs
- [ ] Include troubleshooting sections
- [ ] Add configuration examples
- [ ] Test guides with fresh installations
### Story 1.4: Develop Quick-Start Documentation (3 points) - TODO
**Status**: TODO
**Acceptance Criteria**:
- [ ] Create 5-minute quick-start guide
- [ ] Include common use case examples
- [ ] Add video walkthrough scripts
- [ ] Validate with new users
### Story 1.5: Implement Documentation Standards (2 points) - TODO
**Status**: TODO
**Acceptance Criteria**:
- [ ] Create documentation style guide
- [ ] Implement automated formatting checks
- [ ] Set up documentation review process
- [ ] Create contribution guidelines
## Sprint Progress
- **Completed**: 16/26 story points (62%)
- **In Progress**: 0 story points
- **Remaining**: 10 story points
- **Days Remaining**: 8 days
## Next Actions
1. Complete Product Manager documentation package
2. Complete System Architect documentation package
3. Create Product Owner (Sarah) documentation package
---
*Updated by David - Developer*
View Git Blame Copy Permalink