code-exemplars-blueprint-generator

SKILL.md

Code Exemplars Blueprint Generator

Configuration Variables

${PROJECT_TYPE="Auto-detect|.NET|Java|JavaScript|TypeScript|React|Angular|Python|Other"} 
${SCAN_DEPTH="Basic|Standard|Comprehensive"} 
${INCLUDE_CODE_SNIPPETS=true|false} 
${CATEGORIZATION="Pattern Type|Architecture Layer|File Type"} 
${MAX_EXAMPLES_PER_CATEGORY=3} 
${INCLUDE_COMMENTS=true|false} 

Generated Prompt

"Scan this codebase and generate an exemplars.md file that identifies high-quality, representative code examples. The exemplars should demonstrate our coding standards and patterns to help maintain consistency. Use the following approach:
1. Codebase Analysis Phase

${PROJECT_TYPE == "Auto-detect" ? "Automatically detect primary programming languages and frameworks by scanning file extensions and configuration files" : Focus on ${PROJECT_TYPE} code files}

Identify files with high-quality implementation, good documentation, and clear structure

Look for commonly used patterns, architecture components, and well-structured implementations

Prioritize files that demonstrate best practices for our technology stack

Only reference actual files that exist in the codebase - no hypothetical examples

2. Exemplar Identification Criteria

Well-structured, readable code with clear naming conventions

Comprehensive comments and documentation

Proper error handling and validation

Adherence to design patterns and architectural principles

Separation of concerns and single responsibility principle

Efficient implementation without code smells

Representative of our standard approaches

3. Core Pattern Categories

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

Domain Models: Find entities that properly implement encapsulation and domain logic

Repository Implementations: Examples of our data access approach

Service Layer Components: Well-structured business logic implementations

Controller Patterns: Clean API controllers with proper validation and responses

Dependency Injection Usage: Good examples of DI configuration and usage

Middleware Components: Custom middleware implementations

Unit Test Patterns: Well-structured tests with proper arrangement and assertions` : ""}

${(PROJECT_TYPE == "JavaScript" || PROJECT_TYPE == "TypeScript" || PROJECT_TYPE == "React" || PROJECT_TYPE == "Angular" || PROJECT_TYPE == "Auto-detect") ? `#### Frontend Exemplars (if detected)

Component Structure: Clean, well-structured components

State Management: Good examples of state handling

API Integration: Well-implemented service calls and data handling

Form Handling: Validation and submission patterns

Routing Implementation: Navigation and route configuration

UI Components: Reusable, well-structured UI elements

Unit Test Examples: Component and service tests` : ""}

${PROJECT_TYPE == "Java" || PROJECT_TYPE == "Auto-detect" ? `#### Java Exemplars (if detected)

Entity Classes: Well-designed JPA entities or domain models

Service Implementations: Clean service layer components

Repository Patterns: Data access implementations

Controller/Resource Classes: API endpoint implementations

Configuration Classes: Application configuration

Unit Tests: Well-structured JUnit tests` : ""}

${PROJECT_TYPE == "Python" || PROJECT_TYPE == "Auto-detect" ? `#### Python Exemplars (if detected)

Class Definitions: Well-structured classes with proper documentation

API Routes/Views: Clean API implementations

Data Models: ORM model definitions

Service Functions: Business logic implementations

Utility Modules: Helper and utility functions

Test Cases: Well-structured unit tests` : ""}

4. Architecture Layer Exemplars

Presentation Layer:

User interface components

Controllers/API endpoints

View models/DTOs

Business Logic Layer:

Service implementations

Business logic components

Workflow orchestration

Data Access Layer:

Repository implementations

Data models

Query patterns

Cross-Cutting Concerns:

Logging implementations

Error handling

Authentication/authorization

Validation

5. Exemplar Documentation Format

For each identified exemplar, document:

File path (relative to repository root)

Brief description of what makes it exemplary

Pattern or component type it represents
${INCLUDE_COMMENTS ? "- Key implementation details and coding principles demonstrated" : ""}
${INCLUDE_CODE_SNIPPETS ? "- Small, representative code snippet (if applicable)" : ""}

${SCAN_DEPTH == "Comprehensive" ? `### 6. Additional Documentation

Consistency Patterns: Note consistent patterns observed across the codebase

Architecture Observations: Document architectural patterns evident in the code

Implementation Conventions: Identify naming and structural conventions

Anti-patterns to Avoid: Note any areas where the codebase deviates from best practices` : ""}

${SCAN_DEPTH == "Comprehensive" ? "7" : "6"}. Output Format

Create exemplars.md with:

Introduction explaining the purpose of the document

Table of contents with links to categories

Organized sections based on ${CATEGORIZATION}

Up to ${MAX_EXAMPLES_PER_CATEGORY} exemplars per category

Conclusion with recommendations for maintaining code quality

The document should be actionable for developers needing guidance on implementing new features consistent with existing patterns.

Important: Only include actual files from the codebase. Verify all file paths exist. Do not include placeholder or hypothetical examples.
"

Expected Output

Upon running this prompt, GitHub Copilot will scan your codebase and generate an exemplars.md file containing real references to high-quality code examples in your repository, organized according to your selected parameters.