generate-custom-instructions-from-codebase
Helps your agent create instructions for GitHub Copilot. It analyzes code differences between versions to maintain consistency during migrations or upgrades.
What it does
This tool compares two versions of a code project to create detailed instructions. These instructions help GitHub Copilot understand and automatically apply necessary changes during updates or refactoring, maintaining code consistency.
When to use it
- ✓When updating a framework or library version.
- ✓When changing the project's architecture or core structure.
- ✓When migrating the project to a new technology or language.
Example of what to ask your AI
“Generate instructions to migrate code from the 'main' version to the 'release-candidate' version, focusing on API changes and dependency updates.”
Want more? Open the sections below.
How to use
The easiest way: copy the message below and paste it into Claude, ChatGPT, Cursor or any AI. It reads the skill and follows the instructions.
Skill link
Ready-to-paste message
How it works
The tool analyzes the differences between the two code versions, identifies change patterns, and creates a step-by-step guide. This guide is used by GitHub Copilot to suggest and automatically apply the correct modifications.
Installation
Easiest way: copy the skill link and paste it into Claude, ChatGPT or Cursor asking it to follow the instructions.
In the terminal (Claude Code, Codex, Cursor), in your project folder:
npx skills add github/awesome-copilot --skill generate-custom-instructions-from-codebaseOr download just the file:
curl -L https://raw.githubusercontent.com/github/awesome-copilot/main/skills/generate-custom-instructions-from-codebase/SKILL.md -o SKILL.mdTechnical content (original SKILL.md)
Original text by the author, straight from GitHub.
Migration and Code Evolution Instructions Generator
Configuration Variables
${MIGRATION_TYPE="Framework Version|Architecture Refactoring|Technology Migration|Dependencies Update|Pattern Changes"}
<!-- Type of migration or evolution -->
${SOURCE_REFERENCE="branch|commit|tag"}
<!-- Source reference point (before state) -->
${TARGET_REFERENCE="branch|commit|tag"}
<!-- Target reference point (after state) -->
${ANALYSIS_SCOPE="Entire project|Specific folder|Modified files only"}
<!-- Scope of analysis -->
${CHANGE_FOCUS="Breaking Changes|New Conventions|Obsolete Patterns|API Changes|Configuration"}
<!-- Main aspect of changes -->
${AUTOMATION_LEVEL="Conservative|Balanced|Aggressive"}
<!-- Level of automation for Copilot suggestions -->
${GENERATE_EXAMPLES="true|false"}
<!-- Include transformation examples -->
${VALIDATION_REQUIRED="true|false"}
<!-- Require validation before application -->
Generated Prompt
"Analyze code evolution between two project states to generate precise migration instructions for GitHub Copilot. These instructions will guide Copilot to automatically apply the same transformation patterns during future modifications. Follow this methodology:
### Phase 1: Comparative State Analysis
#### Structural Changes Detection
- Compare folder structure between ${SOURCE_REFERENCE} and ${TARGET_REFERENCE}
- Identify moved, renamed, or deleted files
- Analyze changes in configuration files
- Document new dependencies and removed ones
#### Code Transformation Analysis
${MIGRATION_TYPE == "Framework Version" ?
"- Identify API changes between framework versions
- Analyze new features being used
- Document obsolete methods/properties
- Note syntax or convention changes" : ""}
${MIGRATION_TYPE == "Architecture Refactoring" ?
"- Analyze architectural pattern changes
- Identify new abstractions introduced
- Document responsibility reorganization
- Note changes in data flows" : ""}
${MIGRATION_TYPE == "Technology Migration" ?
"- Analyze replacement of one technology with another
- Identify functional equivalences
- Document API and syntax changes
- Note new dependencies and configurations" : ""}
#### Transformation Pattern Extraction
- Identify repetitive transformations applied
- Analyze conversion rules from old to new format
- Document exceptions and special cases
- Create before/after correspondence matrix
### Phase 2: Migration Instructions Generation
Create a `.github/copilot-migration-instructions.md` file with this structure:
\`\`\`markdown
# GitHub Copilot Migration Instructions
## Migration Context
- **Type**: ${MIGRATION_TYPE}
- **From**: ${SOURCE_REFERENCE}
- **To**: ${TARGET_REFERENCE}
- **Date**: [GENERATION_DATE]
- **Scope**: ${ANALYSIS_SCOPE}
## Automatic Transformation Rules
### 1. Mandatory Transformations
${AUTOMATION_LEVEL != "Conservative" ?
"[AUTOMATIC_TRANSFORMATION_RULES]
- **Old Pattern**: [OLD_CODE]
- **New Pattern**: [NEW_CODE]
- **Trigger**: When to detect this pattern
- **Action**: Transformation to apply automatically" : ""}
### 2. Transformations with Validation
${VALIDATION_REQUIRED == "true" ?
"[TRANSFORMATIONS_WITH_VALIDATION]
- **Detected Pattern**: [DESCRIPTION]
- **Suggested Transformation**: [NEW_APPROACH]
- **Required Validation**: [VALIDATION_CRITERIA]
- **Alternatives**: [ALTERNATIVE_OPTIONS]" : ""}
### 3. API Correspondences
${CHANGE_FOCUS == "API Changes" || MIGRATION_TYPE == "Framework Version" ?
"[API_CORRESPONDENCE_TABLE]
| Old API | New API | Notes | Example |
| --------- | --------- | --------- | -------------- |
| [OLD_API] | [NEW_API] | [CHANGES] | [CODE_EXAMPLE] | " : ""} |
### 4. New Patterns to Adopt
[DETECTED_EMERGING_PATTERNS]
- **Pattern**: [PATTERN_NAME]
- **Usage**: [WHEN_TO_USE]
- **Implementation**: [HOW_TO_IMPLEMENT]
- **Benefits**: [ADVANTAGES]
### 5. Obsolete Patterns to Avoid
[DETECTED_OBSOLETE_PATTERNS]
- **Obsolete Pattern**: [OLD_PATTERN]
- **Why Avoid**: [REASONS]
- **Alternative**: [NEW_PATTERN]
- **Migration**: [CONVERSION_STEPS]
## File Type Specific Instructions
${GENERATE_EXAMPLES == "true" ?
"### Configuration Files
[CONFIG_TRANSFORMATION_EXAMPLES]
### Main Source Files
[SOURCE_TRANSFORMATION_EXAMPLES]
### Test Files
[TEST_TRANSFORMATION_EXAMPLES]" : ""}
## Validation and Security
### Automatic Control Points
- Verifications to perform after each transformation
…
FAQ
What are 'source' and 'target' references?
These are the starting and ending points of the code you want to compare. They can be branch names, specific commits, or version tags in your project.
What does 'automation level' mean?
It defines how aggressively GitHub Copilot should try to apply changes automatically. 'Conservative' requires more human confirmation, while 'Aggressive' aims to automate as much as possible.
Why do I need instructions for Copilot?
To ensure that changes made in one part of the code are applied consistently throughout the project, especially during major updates or migrations, preventing errors and inconsistencies.
Details
Original description by the author
Migration and code evolution instructions generator for GitHub Copilot. Analyzes differences between two project versions (branches, commits, or releases) to create precise instructions allowing Copilot to maintain consistency during technology migrations, major refactoring, or framework version upgrades.
repo: github/awesome-copilot
Popularity
- GitHub stars
- 40k
- Ranking position
- #5161
- License
- MIT
- Updated
- 10/15/2026
Comments
- …
More skills from this repository
acquire-codebase-knowledge
Helps your agent understand and document an existing code project. It's useful for onboarding new people or getting an overview of the architecture.
github/awesome-copilot
acreadiness-assess
Enables your agent to assess a project's readiness for AI and generate a report. It's useful for understanding how well a project is prepared to use AI tools.
github/awesome-copilot
acreadiness-generate-instructions
Helps your agent create instructions for AI tools based on an assessment. It's useful for improving how AI interacts with code and closing identified gaps.
github/awesome-copilot
acreadiness-policy
Enables your agent to help define or apply policies for AI project assessment. It's useful for standardizing how projects are evaluated and ensuring compliance.
github/awesome-copilot
Similar skills
api-connector-builder
Has your agent build new API connections following the existing pattern. Use when you need to add one more integration without creating a new way of doing things.
affaan-m/ECC
api-design
Helps your agent design REST APIs following best practices. It's useful for defining how APIs communicate, how errors are shown, and how to organize data.
affaan-m/ECC
backend-patterns
Helps your agent with server-side architecture patterns and database optimization. It's useful for building or reviewing code that runs on the server.
affaan-m/ECC