/architecture-review

Architecture Review Command

Review and improve system architecture

Instructions

Perform a comprehensive architectural analysis following these steps:

1. **High-Level Architecture Analysis**

• Map out the overall system architecture and components
• Identify architectural patterns in use (MVC, MVP, Clean Architecture, etc.)
• Review module boundaries and separation of concerns
• Analyze the application's layered structure

2. **Design Patterns Assessment**

• Identify design patterns used throughout the codebase
• Check for proper implementation of common patterns
• Look for anti-patterns and code smells
• Assess pattern consistency across the application

3. **Dependency Management**

• Review dependency injection and inversion of control
• Analyze coupling between modules and components
• Check for circular dependencies
• Assess dependency direction and adherence to dependency rule

4. **Data Flow Architecture**

• Trace data flow through the application
• Review state management patterns and implementation
• Analyze data persistence and storage strategies
• Check for proper data validation and transformation

5. **Component Architecture**

• Review component design and responsibilities
• Check for single responsibility principle adherence
• Analyze component composition and reusability
• Assess interface design and abstraction levels

6. **Error Handling Architecture**

• Review error handling strategy and consistency
• Check for proper error propagation and recovery
• Analyze logging and monitoring integration
• Assess resilience and fault tolerance patterns

7. **Scalability Assessment**

• Analyze horizontal and vertical scaling capabilities
• Review caching strategies and implementation
• Check for stateless design where appropriate
• Assess performance bottlenecks and scaling limitations

8. **Security Architecture**

• Review security boundaries and trust zones
• Check authentication and authorization architecture
• Analyze data protection and privacy measures
• Assess security pattern implementation

9. **Testing Architecture**

• Review test structure and organization
• Check for testability in design
• Analyze mocking and dependency isolation strategies
• Assess test coverage across architectural layers

10. **Configuration Management**

• Review configuration handling and environment management
• Check for proper separation of config from code
• Analyze feature flags and runtime configuration
• Assess deployment configuration strategies

11. **Documentation & Communication**

• Review architectural documentation and diagrams
• Check for clear API contracts and interfaces
• Assess code self-documentation and clarity
• Analyze team communication patterns in code

12. **Future-Proofing & Extensibility**

• Assess the architecture's ability to accommodate change
• Review extension points and plugin architectures
• Check for proper versioning and backward compatibility
• Analyze migration and upgrade strategies

13. **Technology Choices**

• Review technology stack alignment with requirements
• Assess framework and library choices
• Check for consistent technology usage
• Analyze technical debt and modernization opportunities

14. **Performance Architecture**

• Review caching layers and strategies
• Analyze asynchronous processing patterns
• Check for proper resource management
• Assess monitoring and observability architecture

15. **Recommendations**

• Provide specific architectural improvements
• Suggest refactoring strategies for problem areas
• Recommend patterns and practices for better design
• Create a roadmap for architectural evolution

Focus on providing actionable insights with specific examples and clear rationale for recommendations.