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"}  ${CATEGORIZATION="Technology Type|Layer|Purpose"}

Generated Prompt

"Analyze 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
Analyze 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 organization 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 organization
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 categorized 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 organization
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 organization conventions
Interface/abstract class patterns

Code Organization

File structure and organization
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 organization
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 customizations
Extension points and customizations

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 utilized
Monitoring and logging infrastructure" : ""}

6. Technology-Specific Implementation Details

${PROJECT_TYPE == ".NET" || PROJECT_TYPE == "Auto-detect" ? "#### .NET Implementation Details (if detected)

Dependency Injection Pattern:
- Service registration approach (Scoped/Singleton/Transient patterns)
- Configuration binding patterns
Controller Patterns:
- Base controller usage
- Action result types and patterns
- Route attribute conventions
- Filter usage (authorization, validation, etc.)
Data Access Patterns:
- ORM configuration and usage
- Entity configuration approach
- Relationship definitions
- Query patterns and optimization approaches
API Design Patterns (if used):
- Endpoint organization
- Parameter binding approaches
- Response type handling
Language Features Used:
- Detect specific language features from code
- Identify common patterns and idioms
- Note any specific version-dependent features" : ""}

${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 types
Code Snippets: Ready-to-use code patterns for common operations
Implementation Checklist: Standard steps for implementing features end-to-end
Integration Points: How to connect new code with existing systems
Testing Requirements: Standard test patterns for different component types
Documentation Requirements: Standard doc patterns for new features" : ""}

${INCLUDE_DIAGRAMS ? "### 8. Technology Relationship Diagrams

Stack Diagram: Visual representation of the complete technology stack
Dependency Flow: How different technologies interact
Component Relationships: How major components depend on each other
Data 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 categorize technologies by ${CATEGORIZATION}.

Save the output as 'Technology_Stack_Blueprint.${OUTPUT_FORMAT == "Markdown" ? "md" : OUTPUT_FORMAT.toLowerCase()}' "

technology-stack-blueprint-generator

Safety Notice

Copy this and send it to your AI assistant to learn