| name | architecture |
| description | Comprehensive system architecture design and implementation workflow that orchestrates expert analysis, technical decision-making, and architectural pattern selection using the integrated toolset. Handles everything from initial system analysis to implementation-ready technical specifications. |
| license | Apache 2.0 |
| tools | [] |
Architecture Master - Complete System Architecture Design Workflow
Overview
This skill provides end-to-end architecture design and implementation guidance by orchestrating multiple expert systems and tools available in this repository. It bridges business requirements with technical implementation, ensuring robust, scalable, and maintainable system architectures.
Key Capabilities:
- 🏗️ Multi-Expert Architecture Analysis - Coordinates system, backend, frontend, DevOps, and security architects
- 🎯 Intelligent Pattern Selection - Automatically selects appropriate architectural patterns based on requirements
- 📊 Scalability Planning - Designs for 10x growth with bottleneck analysis
- 🔒 Security-First Design - Integrates security considerations at every layer
- 📋 Implementation Guidance - Provides detailed implementation roadmaps and best practices
When to Use This Skill
Perfect for:
- New system architecture design and planning
- Legacy system modernization and migration strategies
- Microservices decomposition and service boundary definition
- API design and integration architecture
- Performance optimization and scalability planning
- DevOps and infrastructure architecture design
- Security architecture and compliance requirements
Triggers:
- "Help me design the architecture for..."
- "I need to refactor/upgrade our system architecture"
- "Design a microservices architecture for..."
- "Create an API architecture for..."
- "Plan the DevOps infrastructure for..."
- "Design a scalable system architecture..."
Architecture Expert Panel
The skill orchestrates multiple architectural perspectives:
System Architect (Holistic Design)
- Focus: System boundaries, scalability, long-term maintainability
- Patterns: Microservices, DDD, Event Sourcing, CQRS
- Considerations: 10x growth, component coupling, technology evolution
Backend Architect (Data & Services)
- Focus: API design, data integrity, fault tolerance
- Patterns: RESTful APIs, GraphQL, Database Architecture
- Considerations: ACID compliance, security, performance
Frontend Architect (User Experience)
- Focus: Component architecture, state management, performance
- Patterns: SPA, Micro-Frontends, Progressive Web Apps
- Considerations: User experience, performance optimization
DevOps Architect (Infrastructure & Reliability)
- Focus: CI/CD, observability, deployment strategies
- Patterns: IaC, Container Orchestration, Cloud Native
- Considerations: Reliability, monitoring, disaster recovery
Security Architect (Protection & Compliance)
- Focus: Security by design, threat modeling, compliance
- Patterns: Zero Trust, Defense in Depth, Security Controls
- Considerations: Data protection, regulatory compliance
Architecture Design Workflow
Phase 1: Requirements Analysis & Context Understanding
Use when: Starting any architecture project
Tools Used:
/sc:analyze existing-system/requirements
/speckit.specify architecture-requirements
BMAD Architect Agent: *research {domain}
Activities:
- Analyze business requirements and technical constraints
- Evaluate existing system landscape and integration points
- Identify scalability and performance requirements
- Assess security and compliance requirements
- Map stakeholder concerns and success criteria
Phase 2: System Analysis & Architecture Strategy
Use when: Understanding current state and defining approach
Tools Used:
/sc:analyze system-landscape
/sc:business-panel "system-analysis-and-approach"
System Architect Agent: holistic analysis
Activities:
- Map current system dependencies and interactions
- Identify architectural debt and technical constraints
- Evaluate technology stack and infrastructure capabilities
- Assess team skills and development processes
- Define architectural principles and constraints
Phase 3: Pattern Selection & Design Decisions
Use when: Making key architectural choices
Tools Used:
/sc:spec-panel --experts "martin-fowler,sam-newman,michael-nygard" --focus architecture
/sc:design --type architecture system-components
OpenSpec: Architecture change proposal
Activities:
- Select appropriate architectural patterns (microservices, monolith, serverless)
- Define service boundaries and interaction patterns
- Design data architecture and persistence strategies
- Choose integration patterns and communication protocols
- Document architectural decisions with trade-off analysis
Phase 4: Detailed Architecture Design
Use when: Creating comprehensive specifications
Tools Used:
/sc:design --type api --format spec rest-api-design
/sc:design --type database --format diagram data-architecture
BMAD Architect Agent: create-architecture-document
Activities:
- Design system components and their interfaces
- Define API specifications and data contracts
- Design database schemas and data models
- Plan caching, messaging, and integration strategies
- Create deployment and infrastructure architecture
Phase 5: Security & Compliance Architecture
Use when: Ensuring robust security posture
Tools Used:
Security Architect Agent: comprehensive security analysis
/sc:troubleshoot "security-vulnerability-assessment"
Compliance Checklist validation
Activities:
- Conduct threat modeling and security assessment
- Design authentication, authorization, and encryption strategies
- Implement logging, monitoring, and audit capabilities
- Ensure compliance with relevant regulations (GDPR, SOC2, etc.)
- Define security controls and incident response procedures
Phase 6: Implementation Planning & Roadmap
Use when: Creating implementation strategy
Tools Used:
/speckit.tasks architecture-implementation
/sc:spawn "architecture-implementation-coordination"
BMAD DevOps Agent: deployment-strategy
Activities:
- Create phased implementation roadmap
- Define migration strategies and rollback procedures
- Plan testing strategies and quality gates
- Design monitoring and observability architecture
- Generate team training and documentation plans
Integration Patterns
SuperClaude Command Integration
| Command | Use Case | Output |
|---|
/sc:design | Core architecture design | System diagrams, API specs |
/sc:spec-panel | Expert review and validation | Quality-assured architecture |
/sc:analyze | System analysis and assessment | Current state analysis |
/sc:business-panel | Strategic alignment | Business-technical bridge |
/sc:spawn | Complex implementation coordination | Cross-domain task management |
BMAD Agent Orchestration
| Agent | Role | Capabilities |
|---|
| Winston (Architect) | Lead architect | Holistic system design, technology selection |
| Backend Architect | Service design | API design, database architecture |
| Frontend Architect | UI/UX architecture | Component design, performance |
| DevOps Architect | Infrastructure | CI/CD, deployment, monitoring |
| Security Architect | Security | Threat modeling, compliance |
Specialized MCP Agents
| Agent | Expertise | Focus |
|---|
| System Architect | Large-scale systems | Scalability, boundaries |
| Backend Architect | Data systems | Reliability, performance |
| DevOps Architect | Operations | Automation, reliability |
| Cloud Architect | Cloud infrastructure | Multi-cloud, optimization |
Usage Examples
Example 1: New Microservices System
User: "Help me design the architecture for an e-commerce platform with microservices"
Workflow:
1. Phase 1: Analyze e-commerce requirements and patterns
2. Phase 2: Evaluate monolith vs microservices approach
3. Phase 3: Service boundary definition and API contracts
4. Phase 4: Detailed service architecture and data flow
5. Phase 5: Payment processing security architecture
6. Phase 6: Implementation roadmap with migration strategy
Example 2: Legacy System Modernization
User: "I need to modernize our 10-year-old monolithic application"
Workflow:
1. Phase 1: Comprehensive system analysis and assessment
2. Phase 2: Strangler Fig pattern planning and execution
3. Phase 3: Microservice decomposition strategy
4. Phase 4: API gateway and service mesh design
5. Phase 5: Data migration and modernization planning
6. Phase 6: Phased rollout and risk mitigation
Example 3: High-Performance API System
User: "Design architecture for a high-performance API that handles millions of requests"
Workflow:
1. Phase 1: Performance requirements and load analysis
2. Phase 2: Scalability architecture and technology selection
3. Phase 3: API design with caching and optimization
4. Phase 4: Database architecture for high throughput
5. Phase 5: Monitoring and observability design
6. Phase 6: Performance testing and optimization roadmap
Quality Assurance Mechanisms
Multi-Expert Validation
- Spec Panel: Martin Fowler, Sam Newman, Michael Nygard review
- Architectural Reviews: Multiple architect perspectives and cross-validation
- Pattern Compliance: Ensure architectural patterns are correctly implemented
- Security Validation: Comprehensive security review and threat modeling
Automated Checks
- Scalability Analysis: Automated bottleneck identification
- Dependency Analysis: System dependency mapping and risk assessment
- Compliance Validation: Regulatory and industry standard compliance checks
- Performance Validation: Performance modeling and bottleneck prediction
Best Practice Integration
- Industry Standards: Adherence to architectural best practices
- Technology Alignment: Consistent with technology stack and organizational capabilities
- Maintainability: Future-proof design and evolution planning
- Documentation Standards: Comprehensive architectural documentation
Output Deliverables
Primary Deliverable: Complete Architecture Package
architecture-package/
├── docs/
│ ├── architecture-overview.md # Executive summary
│ ├── system-architecture.md # Detailed system design
│ ├── api-architecture.md # API specifications
│ ├── data-architecture.md # Data and database design
│ ├── security-architecture.md # Security design
│ ├── deployment-architecture.md # Infrastructure design
│ └── migration-strategy.md # Implementation roadmap
├── diagrams/
│ ├── system-overview.png # High-level architecture diagram
│ ├── component-diagram.png # Component interaction diagram
│ ├── data-flow.png # Data flow diagram
│ └── deployment-diagram.png # Deployment architecture
├── decisions/
│ ├── architectural-decisions.md # Decision log with rationale
│ ├── trade-offs.md # Trade-off analysis
│ └── technology-selection.md # Technology evaluation
├── checklists/
│ ├── architecture-review.md # Quality validation checklist
│ ├── security-checklist.md # Security validation
│ ├── performance-checklist.md # Performance validation
│ └── scalability-checklist.md # Scalability validation
└── implementation/
├── implementation-roadmap.md # Phased implementation plan
├── team-guidelines.md # Development team guidelines
├── testing-strategy.md # Testing and validation plan
└── monitoring-strategy.md # Observability plan
Supporting Artifacts
- OpenSpec Change Files: Structured architectural change proposals
- BMAD Template Outputs: Standardized architecture documentation
- SpeckIT Task Plans: Detailed implementation task breakdowns
- Expert Panel Reports: Multi-expert validation and recommendations
Advanced Features
Intelligent Pattern Matching
- Automatically suggests appropriate architectural patterns based on requirements
- Pattern library with implementation guidance and best practices
- Pattern evolution planning and adaptation strategies
Technology Stack Analysis
- Evaluates existing technology stack against requirements
- Recommends technology upgrades and migration paths
- Considers team skills, organizational context, and budget constraints
Risk Assessment
- Identifies architectural risks and failure modes
- Provides mitigation strategies and contingency planning
- Includes business impact analysis and risk scoring
Cost Optimization
- Analyzes total cost of ownership (TCO) for architectural decisions
- Optimizes infrastructure costs and licensing strategies
- Balances technical excellence with financial reality
Troubleshooting
Common Architectural Challenges
- Monolith to Microservices Transition: Use Strangler Fig pattern with gradual migration
- Performance Bottlenecks: Comprehensive performance analysis with optimization strategies
- Security Compliance: Layered security approach with defense-in-depth principles
- Team Skills Gap: Training recommendations and hiring strategies
Architecture Decision Recovery
- Pattern Selection Issues: Re-evaluate requirements and match patterns appropriately
- Technology Trade-offs: Re-assess technical decisions with updated requirements
- Integration Challenges: Design adaptive integration patterns and APIs
- Scalability Problems: Identify scaling bottlenecks and redesign hot components
Best Practices
For System Design
- Start with clear system boundaries and interfaces
- Design for failure with fault isolation and recovery
- Implement observability from the beginning
- Plan for evolution and future changes
For Technology Selection
- Choose boring technology when possible
- Consider team expertise and learning curves
- Evaluate long-term maintenance and support
- Balance technical excellence with practical constraints
For Security
- Implement security by design, not as an afterthought
- Use multiple layers of security controls
- Regular security assessments and penetration testing
- Stay updated with security best practices and threat landscapes
For Scalability
- Design for horizontal scaling from the start
- Identify and optimize performance bottlenecks
- Use caching and data partitioning strategies
- Plan for capacity growth and load distribution
This architecture skill transforms the complex process of system architecture design into a guided, expert-supported workflow that leverages the full power of your integrated development toolset. It ensures that architectural decisions are well-reasoned, thoroughly validated, and aligned with both business requirements and long-term technical strategy.
