architecture-blueprint-generator

SKILL.md

Comprehensive Project Architecture Blueprint Generator

Configuration Variables

${PROJECT_TYPE="Auto-detect|.NET|Java|React|Angular|Python|Node.js|Flutter|Other"} 
${ARCHITECTURE_PATTERN="Auto-detect|Clean Architecture|Microservices|Layered|MVVM|MVC|Hexagonal|Event-Driven|Serverless|Monolithic|Other"} 
${DIAGRAM_TYPE="C4|UML|Flow|Component|None"} 
${DETAIL_LEVEL="High-level|Detailed|Comprehensive|Implementation-Ready"} 
${INCLUDES_CODE_EXAMPLES=true|false} 
${INCLUDES_IMPLEMENTATION_PATTERNS=true|false} 
${INCLUDES_DECISION_RECORDS=true|false} 
${FOCUS_ON_EXTENSIBILITY=true|false} 

Generated Prompt

"Create a comprehensive 'Project_Architecture_Blueprint.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

${DIAGRAM_TYPE != "None" ? `Create ${DIAGRAM_TYPE} 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

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

${(PROJECT_TYPE == ".NET" || PROJECT_TYPE == "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" : ""}

${(PROJECT_TYPE == "Java" || PROJECT_TYPE == "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" : ""}

${(PROJECT_TYPE == "React" || PROJECT_TYPE == "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" : ""}

${(PROJECT_TYPE == "Angular" || PROJECT_TYPE == "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" : ""}

${(PROJECT_TYPE == "Python" || PROJECT_TYPE == "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

${INCLUDES_IMPLEMENTATION_PATTERNS ?
"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

${FOCUS_ON_EXTENSIBILITY ?
"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."}

${INCLUDES_CODE_EXAMPLES ?
"### 14. Architectural Pattern Examples
Extract representative code examples that illustrate key architectural patterns:

Layer Separation Examples:

Interface definition and implementation separation

Cross-layer communication patterns

Dependency injection examples

Component Communication Examples:

Service invocation patterns

Event publication and handling

Message passing implementation

Extension Point Examples:

Plugin registration and discovery

Extension interface implementations

Configuration-driven extension patterns

Include enough context with each example to show the pattern clearly, but keep examples concise and focused on architectural concepts." : ""}

${INCLUDES_DECISION_RECORDS ?
"### 15. Architectural Decision Records
Document key architectural decisions evident in the codebase:

Architectural Style Decisions:

Why the current architectural pattern was chosen

Alternatives considered (based on code evolution)

Constraints that influenced the decision

Technology Selection Decisions:

Key technology choices and their architectural impact

Framework selection rationales

Custom vs. off-the-shelf component decisions

Implementation Approach Decisions:

Specific implementation patterns chosen

Standard pattern adaptations

Performance vs. maintainability tradeoffs

For each decision, note:

Context that made the decision necessary

Factors considered in making the decision

Resulting consequences (positive and negative)

Future flexibility or limitations introduced" : ""}

${INCLUDES_DECISION_RECORDS ? "16" : INCLUDES_CODE_EXAMPLES ? "15" : "14"}. Architecture Governance

Document how architectural consistency is maintained

Identify automated checks for architectural compliance

Note architectural review processes evident in the codebase

Document architectural documentation practices

${INCLUDES_DECISION_RECORDS ? "17" : INCLUDES_CODE_EXAMPLES ? "16" : "15"}. Blueprint for New Development

Create a clear architectural guide for implementing new features:

Development Workflow:

Starting points for different feature types

Component creation sequence

Integration steps with existing architecture

Testing approach by architectural layer

Implementation Templates:

Base class/interface templates for key architectural components

Standard file organization for new components

Dependency declaration patterns

Documentation requirements

Common Pitfalls:

Architecture violations to avoid

Common architectural mistakes

Performance considerations

Testing blind spots

Include information about when this blueprint was generated and recommendations for keeping it updated as the architecture evolves."