architecture-blueprint-generator skill

Comprehensive Project Architecture Blueprint Generator

Configuration Variables

${PROJECTTYPE="Auto-detect|.NET|Java|React|Angular|Python|Node.js|Flutter|Other"} <!-- Primary technology --> ${ARCHITECTUREPATTERN="Auto-detect|Clean Architecture|Microservices|Layered|MVVM|MVC|Hexagonal|Event-Driven|Serverless|Monolithic|Other"} <!-- Primary architectural pattern --> ${DIAGRAMTYPE="C4|UML|Flow|Component|None"} <!-- Architecture diagram type --> ${DETAILLEVEL="High-level|Detailed|Comprehensive|Implementation-Ready"} <!-- Level of detail to include --> ${INCLUDESCODEEXAMPLES=true|false} <!-- Include sample code to illustrate patterns --> ${INCLUDESIMPLEMENTATIONPATTERNS=true|false} <!-- Include detailed implementation patterns --> ${INCLUDESDECISIONRECORDS=true|false} <!-- Include architectural decision records --> ${FOCUSONEXTENSIBILITY=true|false} <!-- Emphasize extension points and patterns -->

Generated Prompt

"Create a comprehensive 'ProjectArchitectureBlueprint.md' document that thoroughly analyzes the architectural patterns in the codebase to serve as a definitive reference for maintaining architectural consistency. Use the following approach:

1. Architecture Detection and Analysis

• ${PROJECT_TYPE == "Auto-detect" ? "Analyze the project structure to identify all technology stacks and frameworks in use by examining:
• Project and configuration files
• Package dependencies and import statements
• Framework-specific patterns and conventions
• Build and deployment configurations" : "Focus on ${PROJECT_TYPE} specific patterns and practices"}

• ${ARCHITECTURE_PATTERN == "Auto-detect" ? "Determine the architectural pattern(s) by analyzing:
• Folder organization and namespacing
• Dependency flow and component boundaries
• Interface segregation and abstraction patterns
• Communication mechanisms between components" : "Document how the ${ARCHITECTURE_PATTERN} architecture is implemented"}

2. Architectural Overview

• Provide a clear, concise explanation of the overall architectural approach
• Document the guiding principles evident in the architectural choices
• Identify architectural boundaries and how they're enforced
• Note any hybrid architectural patterns or adaptations of standard patterns

3. Architecture Visualization

${DIAGRAMTYPE != "None" ? Create ${DIAGRAMTYPE} diagrams at multiple levels of abstraction:

• High-level architectural overview showing major subsystems
• Component interaction diagrams showing relationships and dependencies
• Data flow diagrams showing how information moves through the system
• Ensure diagrams accurately reflect the actual implementation, not theoretical patterns : "Describe the component relationships based on actual code dependencies, providing clear textual explanations of:
• Subsystem organization and boundaries
• Dependency directions and component interactions
• Data flow and process sequences"}

4. Core Architectural Components

For each architectural component discovered in the codebase:

• Purpose and Responsibility:
• Primary function within the architecture
• Business domains or technical concerns addressed
• Boundaries and scope limitations

• Internal Structure:
• Organization of classes/modules within the component
• Key abstractions and their implementations
• Design patterns utilized

• Interaction Patterns:
• How the component communicates with others
• Interfaces exposed and consumed
• Dependency injection patterns
• Event publishing/subscription mechanisms

• Evolution Patterns:
• How the component can be extended
• Variation points and plugin mechanisms
• Configuration and customization approaches

5. Architectural Layers and Dependencies

• Map the layer structure as implemented in the codebase
• Document the dependency rules between layers
• Identify abstraction mechanisms that enable layer separation
• Note any circular dependencies or layer violations
• Document dependency injection patterns used to maintain separation

6. Data Architecture

• Document domain model structure and organization
• Map entity relationships and aggregation patterns
• Identify data access patterns (repositories, data mappers, etc.)
• Document data transformation and mapping approaches
• Note caching strategies and implementations
• Document data validation patterns

7. Cross-Cutting Concerns Implementation

Document implementation patterns for cross-cutting concerns:

• Authentication & Authorization:
• Security model implementation
• Permission enforcement patterns
• Identity management approach
• Security boundary patterns

• Error Handling & Resilience:
• Exception handling patterns
• Retry and circuit breaker implementations
• Fallback and graceful degradation strategies
• Error reporting and monitoring approaches

• Logging & Monitoring:
• Instrumentation patterns
• Observability implementation
• Diagnostic information flow
• Performance monitoring approach

• Validation:
• Input validation strategies
• Business rule validation implementation
• Validation responsibility distribution
• Error reporting patterns

• Configuration Management:
• Configuration source patterns
• Environment-specific configuration strategies
• Secret management approach
• Feature flag implementation

8. Service Communication Patterns

• Document service boundary definitions
• Identify communication protocols and formats
• Map synchronous vs. asynchronous communication patterns
• Document API versioning strategies
• Identify service discovery mechanisms
• Note resilience patterns in service communication

9. Technology-Specific Architectural Patterns

${PROJECTTYPE == "Auto-detect" ? "For each detected technology stack, document specific architectural patterns:" : Document ${PROJECTTYPE}-specific architectural patterns:}

${(PROJECTTYPE == ".NET" || PROJECTTYPE == "Auto-detect") ? "#### .NET Architectural Patterns (if detected)

• Host and application model implementation
• Middleware pipeline organization
• Framework service integration patterns
• ORM and data access approaches
• API implementation patterns (controllers, minimal APIs, etc.)
• Dependency injection container configuration" : ""}

${(PROJECTTYPE == "Java" || PROJECTTYPE == "Auto-detect") ? "#### Java Architectural Patterns (if detected)

• Application container and bootstrap process
• Dependency injection framework usage (Spring, CDI, etc.)
• AOP implementation patterns
• Transaction boundary management
• ORM configuration and usage patterns
• Service implementation patterns" : ""}

${(PROJECTTYPE == "React" || PROJECTTYPE == "Auto-detect") ? "#### React Architectural Patterns (if detected)

• Component composition and reuse strategies
• State management architecture
• Side effect handling patterns
• Routing and navigation approach
• Data fetching and caching patterns
• Rendering optimization strategies" : ""}

${(PROJECTTYPE == "Angular" || PROJECTTYPE == "Auto-detect") ? "#### Angular Architectural Patterns (if detected)

• Module organization strategy
• Component hierarchy design
• Service and dependency injection patterns
• State management approach
• Reactive programming patterns
• Route guard implementation" : ""}

${(PROJECTTYPE == "Python" || PROJECTTYPE == "Auto-detect") ? "#### Python Architectural Patterns (if detected)

• Module organization approach
• Dependency management strategy
• OOP vs. functional implementation patterns
• Framework integration patterns
• Asynchronous programming approach" : ""}

10. Implementation Patterns

${INCLUDESIMPLEMENTATIONPATTERNS ? "Document concrete implementation patterns for key architectural components:

• Interface Design Patterns:
• Interface segregation approaches
• Abstraction level decisions
• Generic vs. specific interface patterns
• Default implementation patterns

• Service Implementation Patterns:
• Service lifetime management
• Service composition patterns
• Operation implementation templates
• Error handling within services

• Repository Implementation Patterns:
• Query pattern implementations
• Transaction management
• Concurrency handling
• Bulk operation patterns

• Controller/API Implementation Patterns:
• Request handling patterns
• Response formatting approaches
• Parameter validation
• API versioning implementation

• Domain Model Implementation:
• Entity implementation patterns
• Value object patterns
• Domain event implementation
• Business rule enforcement" : "Mention that detailed implementation patterns vary across the codebase."}

11. Testing Architecture

• Document testing strategies aligned with the architecture
• Identify test boundary patterns (unit, integration, system)
• Map test doubles and mocking approaches
• Document test data strategies
• Note testing tools and frameworks integration

12. Deployment Architecture

• Document deployment topology derived from configuration
• Identify environment-specific architectural adaptations
• Map runtime dependency resolution patterns
• Document configuration management across environments
• Identify containerization and orchestration approaches
• Note cloud service integration patterns

13. Extension and Evolution Patterns

${FOCUSONEXTENSIBILITY ? "Provide detailed guidance for extending the architecture:

• Feature Addition Patterns:
• How to add new features while preserving architectural integrity
• Where to place new components by type
• Dependency introduction guidelines
• Configuration extension patterns

• Modification Patterns:
• How to safely modify existing components
• Strategies for maintaining backward compatibility
• Deprecation patterns
• Migration approaches

• Integration Patterns:
• How to integrate new external systems
• Adapter implementation patterns
• Anti-corruption layer patterns
• Service facade implementation" : "Document key extension points in the architecture."}