Architecture Blueprint Generator
Turn an existing repo into a comprehensive Project_Architecture_Blueprint.md with stack detection, diagrams, patterns, and extension points.
Overview
Architecture Blueprint Generator is an agent skill most often used in Build (also Ship, Operate) that analyzes a codebase and writes comprehensive architecture blueprint documentation.
Install
npx skills add https://github.com/github/awesome-copilot --skill architecture-blueprint-generatorWhat is this skill?
- Auto-detects technology stack and architectural pattern (Clean, microservices, MVVM, hexagonal, serverless, and more)
- Generates Project_Architecture_Blueprint.md at configurable detail from high-level to implementation-ready
- Optional C4, UML, flow, or component diagrams tied to documented boundaries
- Can include sample code, implementation patterns, ADRs, and extensibility/extension-point emphasis
- Configurable via project type, pattern focus, and inclusion flags for examples and decision records
Adoption & trust: 10.5k installs on skills.sh; 34.6k GitHub stars; 3/3 security scanners passed (skills.sh audits); trending (+100% hot-view momentum).
What problem does it solve?
Your project grew organically and nobody—including future you—has a trustworthy map of patterns, boundaries, and how to extend the system safely.
Who is it for?
Solo developers documenting a real repo before scaling features, hiring help, or handing work to coding agents.
Skip if: Greenfield ideas with no codebase yet, or trivial scripts where formal blueprint overhead exceeds value.
When should I use this skill?
User needs comprehensive project architecture documentation, blueprint generation, stack and pattern analysis, or C4/UML-style diagrams from an existing codebase.
What do I get? / Deliverables
You get a structured Project_Architecture_Blueprint.md (and optional diagrams and ADRs) that agents and humans can follow for consistent new development.
- Project_Architecture_Blueprint.md at chosen detail level
- Optional architecture diagrams and architectural decision record sections
Recommended Skills
Journey fit
Spans multiple journey phases - primary shelf plus alternate fits below.
Architecture blueprints are produced from the live codebase during active development; Build is where structural documentation keeps the team aligned as features land. Docs subphase is the canonical home for generated architecture markdown, ADRs, and diagram-backed references—not one-off README tweaks.
Where it fits
Produce Project_Architecture_Blueprint.md after a major module split so agents know where to add APIs and UI.
Refresh blueprint and diagrams before release to verify documented boundaries match what shipped.
Update architecture notes after adopting serverless or event-driven pieces so on-call and agents share the same map.
How it compares
Documentation generator from repository analysis—not an infrastructure-as-code deploy skill or a runtime monitoring integration.
Common Questions / FAQ
Who is architecture-blueprint-generator for?
Indie and solo builders maintaining SaaS, APIs, or multi-module apps who need living architecture docs derived from the actual code.
When should I use architecture-blueprint-generator?
During Build when documenting structure alongside features; during Ship when preparing review or launch readiness; and during Operate when refreshing docs after infra or module changes.
Is architecture-blueprint-generator safe to install?
Use the Security Audits panel on this Prism page before install; the skill reads your repository broadly—scope agent access and avoid running against repos with embedded secrets.
SKILL.md
READMESKILL.md - Architecture Blueprint Generator
# Comprehensive Project Architecture Blueprint Generator ## Configuration Variables ${PROJECT_TYPE="Auto-detect|.NET|Java|React|Angular|Python|Node.js|Flutter|Other"} <!-- Primary technology --> ${ARCHITECTURE_PATTERN="Auto-detect|Clean Architecture|Microservices|Layered|MVVM|MVC|Hexagonal|Event-Driven|Serverless|Monolithic|Other"} <!-- Primary architectural pattern --> ${DIAGRAM_TYPE="C4|UML|Flow|Component|None"} <!-- Architecture diagram type --> ${DETAIL_LEVEL="High-level|Detailed|Comprehensive|Implementation-Ready"} <!-- Level of detail to include --> ${INCLUDES_CODE_EXAMPLES=true|false} <!-- Include sample code to illustrate patterns --> ${INCLUDES_IMPLEMENTATION_PATTERNS=true|false} <!-- Include detailed implementation patterns --> ${INCLUDES_DECISION_RECORDS=true|false} <!-- Include architectural decision records --> ${FOCUS_ON_EXTENSIBILITY=true|false} <!-- Emphasize extension points and patterns --> ## 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 - **Evo