Skip to main content Home Creators marielynneblock arcanum-artifex technology-stack-blueprint-generator
technology-stack-blueprint-generator Comprehensive technology stack blueprint generator that analyses codebases to create detailed architectural documentation. Automatically detects technology stacks, programming languages, and implementation patterns across multiple platforms (.NET, Java, JavaScript, React, Python). Generates configurable blueprints with version information, licensing details, usage patterns, coding conventions, and visual diagrams. Provides implementation-ready templates and maintains architectural consistency for guided development.
Jump to install Skills Marketplace Discover and explore AI skills built by the community.
Install with Codex or Claude Copy this prompt, paste it into Codex, Claude, or another assistant, and let it review the skill page and install it for you.
Show prompt details A direct command skips the review prompt. Inspect the source before running it.
npx skills add https://github.com/MarieLynneBlock/arcanum-artifex --skill technology-stack-blueprint-generatorThe command stays on one line. Scroll horizontally to inspect it before copying.
Prefer a local copy? Download the files currently available to SkillsMP.
Download Zip Downloading... More from this repository
Related occupations SOC
Based on SOC occupation classification
name technology-stack-blueprint-generator description Comprehensive technology stack blueprint generator that analyses codebases to create detailed architectural documentation. Automatically detects technology stacks, programming languages, and implementation patterns across multiple platforms (.NET, Java, JavaScript, React, Python). Generates configurable blueprints with version information, licensing details, usage patterns, coding conventions, and visual diagrams. Provides implementation-ready templates and maintains architectural consistency for guided development. metadata {"skill-author":"Marie-Lynne Block"}
Comprehensive Technology Stack Blueprint Generator
Configuration Variables
${PROJECT_TYPE="Auto-detect|.NET|Java|JavaScript|React.js|React Native|Angular|Python|Other"}
${DEPTH_LEVEL="Basic|Standard|Comprehensive|Implementation-Ready"}
${INCLUDE_VERSIONS=true|false}
${INCLUDE_LICENSES=true|false}
${INCLUDE_DIAGRAMS=true|false}
${INCLUDE_USAGE_PATTERNS=true|false}
${INCLUDE_CONVENTIONS=true|false}
${OUTPUT_FORMAT="Markdown|JSON|YAML|HTML"}
${CATEGORISATION="Technology Type|Layer|Purpose"}
Generated Prompt
"Analyse the codebase and generate a ${DEPTH_LEVEL} technology stack blueprint that thoroughly documents technologies and implementation patterns to facilitate consistent code generation. Use the following approach:
1. Technology Identification Phase
${PROJECT_TYPE == "Auto-detect" ? "Scan the codebase for project files, configuration files, and dependencies to determine all technology stacks in use" : "Focus on ${PROJECT_TYPE} technologies"}
Identify all programming languages by examining file extensions and content
Analyse configuration files (package.json, .csproj, pom.xml, etc.) to extract dependencies
Examine build scripts and pipeline definitions for tooling information
${INCLUDE_VERSIONS ? "Extract precise version information from package files and configuration" : "Skip version details"}
${INCLUDE_LICENSES ? "Document license information for all dependencies" : ""}
2. Core Technologies Analysis ${PROJECT_TYPE == ".NET" || PROJECT_TYPE == "Auto-detect" ? "#### .NET Stack Analysis (if detected)
Target frameworks and language versions (detect from project files)
All NuGet package references with versions and purpose comments
Project structure and organisation patterns
Configuration approach (appsettings.json, IOptions, etc.)
Authentication mechanisms (Identity, JWT, etc.)
API design patterns (REST, GraphQL, minimal APIs, etc.)
Data access approaches (EF Core, Dapper, etc.)
Dependency injection patterns
Middleware pipeline components" : ""}
${PROJECT_TYPE == "Java" || PROJECT_TYPE == "Auto-detect" ? "#### Java Stack Analysis (if detected)
JDK version and core frameworks
All Maven/Gradle dependencies with versions and purpose
Package structure organisation
Spring Boot usage and configurations
Annotation patterns
Dependency injection approach
Data access technologies (JPA, JDBC, etc.)
API design (Spring MVC, JAX-RS, etc.)" : ""}
${PROJECT_TYPE == "JavaScript" || PROJECT_TYPE == "Auto-detect" ? "#### JavaScript Stack Analysis (if detected)
ECMAScript version and transpiler settings
All npm dependencies categorised by purpose
Module system (ESM, CommonJS)
Build tooling (webpack, Vite, etc.) with configuration
TypeScript usage and configuration
Testing frameworks and patterns" : ""}
${PROJECT_TYPE == "React.js" || PROJECT_TYPE == "Auto-detect" ? "#### React Analysis (if detected)
React version and key patterns (hooks vs class components)
State management approach (Context, Redux, Zustand, etc.)
Component library usage (Material-UI, Chakra, etc.)
Routing implementation
Form handling strategies
API integration patterns
Testing approach for components" : ""}
${PROJECT_TYPE == "Python" || PROJECT_TYPE == "Auto-detect" ? "#### Python Analysis (if detected)
Python version and key language features used
Package dependencies and virtual environment setup
Web framework details (Django, Flask, FastAPI)
ORM usage patterns
Project structure organisation
API design patterns" : ""}
3. Implementation Patterns & Conventions ${INCLUDE_CONVENTIONS ?
"Document coding conventions and patterns for each technology area:
Naming Conventions
Class/type naming patterns
Method/function naming patterns
Variable naming conventions
File naming and organisation conventions
Interface/abstract class patterns
Code Organization
File structure and organisation
Folder hierarchy patterns
Component/module boundaries
Code separation and responsibility patterns
Common Patterns
Error handling approaches
Logging patterns
Configuration access
Authentication/authorization implementation
Validation strategies
Testing patterns" : ""}
4. Usage Examples ${INCLUDE_USAGE_PATTERNS ?
"Extract representative code examples showing standard implementation patterns:
API Implementation Examples
Standard controller/endpoint implementation
Request DTO pattern
Response formatting
Validation approach
Error handling
Data Access Examples
Repository pattern implementation
Entity/model definitions
Query patterns
Transaction handling
Service Layer Examples
Service class implementation
Business logic organisation
Cross-cutting concerns integration
Dependency injection usage
UI Component Examples (if applicable)
Component structure
State management pattern
Event handling
API integration pattern" : ""}
5. Technology Stack Map ${DEPTH_LEVEL == "Comprehensive" || DEPTH_LEVEL == "Implementation-Ready" ?
"Create a comprehensive technology map including:
Core Framework Usage
Primary frameworks and their specific usage in the project
Framework-specific configurations and customisations
Extension points and customisations
Integration Points
How different technology components integrate
Authentication flow between components
Data flow between frontend and backend
Third-party service integration patterns
Development Tooling
IDE settings and conventions
Code analysis tools
Linters and formatters with configuration
Build and deployment pipeline
Testing frameworks and approaches
Infrastructure
Deployment environment details
Container technologies
Cloud services utilised
Monitoring and logging infrastructure" : ""}
6. Technology-Specific Implementation Details ${PROJECT_TYPE == ".NET" || PROJECT_TYPE == "Auto-detect" ?
"#### .NET Implementation Details (if detected)
${PROJECT_TYPE == "React.js" || PROJECT_TYPE == "Auto-detect" ?
"#### React Implementation Details (if detected)
Component Structure :
Function vs class components
Props interface definitions
Component composition patterns
Hook Usage Patterns :
Custom hook implementation style
useState patterns
useEffect cleanup approaches
Context usage patterns
State Management :
Local vs global state decisions
State management library patterns
Store configuration
Selector patterns
Styling Approach :
CSS methodology (CSS modules, styled-components, etc.)
Theme implementation
Responsive design patterns" : ""}
7. Blueprint for New Code Implementation ${DEPTH_LEVEL == "Implementation-Ready" ?
"Based on the analysis, provide a detailed blueprint for implementing new features:
File/Class Templates : Standard structure for common component typesCode Snippets : Ready-to-use code patterns for common operationsImplementation Checklist : Standard steps for implementing features end-to-endIntegration Points : How to connect new code with existing systemsTesting Requirements : Standard test patterns for different component typesDocumentation Requirements : Standard doc patterns for new features" : ""} ${INCLUDE_DIAGRAMS ?
"### 8. Technology Relationship Diagrams
Stack Diagram : Visual representation of the complete technology stackDependency Flow : How different technologies interactComponent Relationships : How major components depend on each otherData Flow : How data flows through the technology stack" : ""}
${INCLUDE_DIAGRAMS ? "9" : "8"}. Technology Decision Context
Document apparent reasons for technology choices
Note any legacy or deprecated technologies marked for replacement
Identify technology constraints and boundaries
Document technology upgrade paths and compatibility considerations
Format the output as ${OUTPUT_FORMAT} and categorise technologies by ${CATEGORISATION}.
Save the output as 'Technology_Stack_Blueprint.${OUTPUT_FORMAT == "Markdown" ? "md" : OUTPUT_FORMAT.toLowerCase()}'
"
