update-implementation-plan
github/awesome-copilot
Update implementation plan files with new requirements for features, refactoring, upgrades, and infrastructure changes.
What is update-implementation-plan?
This skill updates existing implementation plan files with new or modified requirements for features, refactoring, package upgrades, design, architecture, or infrastructure changes. Use it when you need to systematically document and structure implementation work in a machine-readable format that other AI agents or humans can execute.
- Generates deterministic, unambiguous implementation plans with discrete phases and atomic tasks
- Structures plans with explicit file paths, function names, and exact implementation details
- Creates machine-parseable output with measurable completion criteria and validation rules
- Organizes work into parallel-executable tasks with explicit dependency declarations
- Includes requirements, constraints, alternatives, dependencies, affected files, tests, and risk assessment
- Produces markdown files following strict template validation rules with front matter metadata
How to install update-implementation-plan
npx skills add https://github.com/github/awesome-copilot --skill update-implementation-planHow to use update-implementation-plan
- 1.Provide the existing implementation plan file path and new/updated requirements
- 2.Specify the type of change (feature, refactor, upgrade, infrastructure, architecture, design, or data)
- 3.Include all constraints, dependencies, and acceptance criteria for the changes
- 4.The skill will update the plan file with new phases, tasks, and requirements following the mandatory template
- 5.Review the generated plan for completeness and validate all identifiers follow the specified format
Use cases
- Adding new features to an existing codebase with clear phase-based execution
- Documenting package upgrade plans with specific version targets and migration steps
- Planning refactoring work with explicit file modifications and validation criteria
- Designing infrastructure or architecture changes with measurable completion criteria
- Creating migration plans for data or system upgrades with dependency tracking
- AI agents executing automated implementation workflows
- Development teams needing structured, executable implementation documentation
- Technical leads planning complex features or refactoring initiatives
- DevOps engineers documenting infrastructure changes
- Project managers tracking implementation progress across phases
update-implementation-plan FAQ
Implementation plans are saved in the `/plan/` directory as Markdown files using the naming convention `[purpose]-[component]-[version].md`, where purpose is one of: upgrade, refactor, feature, data, infrastructure, process, architecture, or design.
Yes. Tasks within a phase can be executed in parallel unless explicit dependencies are declared between them. Each task must include specific file paths, function names, and exact implementation details.
Plans support five status values: Completed (green badge), In progress (yellow badge), Planned (blue badge), Deprecated (red badge), or On Hold (orange badge).
No. All tasks must be written with explicit, unambiguous language requiring zero human interpretation. Each task must include specific file paths, line numbers, and exact code references where applicable.
All plans must include: Introduction with status badge, Requirements & Constraints, Implementation Steps (with phases and tasks), Alternatives, Dependencies, Files, Testing, Risks & Assumptions, and Related Specifications.
Full instructions (SKILL.md)
Source of truth, from github/awesome-copilot.
name: update-implementation-plan description: 'Update an existing implementation plan file with new or update requirements to provide new features, refactoring existing code or upgrading packages, design, architecture or infrastructure.'
Update Implementation Plan
Primary Directive
You are an AI agent tasked with updating the implementation plan file ${file} based on new or updated requirements. Your output must be machine-readable, deterministic, and structured for autonomous execution by other AI systems or humans.
Execution Context
This prompt is designed for AI-to-AI communication and automated processing. All instructions must be interpreted literally and executed systematically without human interpretation or clarification.
Core Requirements
- Generate implementation plans that are fully executable by AI agents or humans
- Use deterministic language with zero ambiguity
- Structure all content for automated parsing and execution
- Ensure complete self-containment with no external dependencies for understanding
Plan Structure Requirements
Plans must consist of discrete, atomic phases containing executable tasks. Each phase must be independently processable by AI agents or humans without cross-phase dependencies unless explicitly declared.
Phase Architecture
- Each phase must have measurable completion criteria
- Tasks within phases must be executable in parallel unless dependencies are specified
- All task descriptions must include specific file paths, function names, and exact implementation details
- No task should require human interpretation or decision-making
AI-Optimized Implementation Standards
- Use explicit, unambiguous language with zero interpretation required
- Structure all content as machine-parseable formats (tables, lists, structured data)
- Include specific file paths, line numbers, and exact code references where applicable
- Define all variables, constants, and configuration values explicitly
- Provide complete context within each task description
- Use standardized prefixes for all identifiers (REQ-, TASK-, etc.)
- Include validation criteria that can be automatically verified
Output File Specifications
- Save implementation plan files in
/plan/directory - Use naming convention:
[purpose]-[component]-[version].md - Purpose prefixes:
upgrade|refactor|feature|data|infrastructure|process|architecture|design - Example:
upgrade-system-command-4.md,feature-auth-module-1.md - File must be valid Markdown with proper front matter structure
Mandatory Template Structure
All implementation plans must strictly adhere to the following template. Each section is required and must be populated with specific, actionable content. AI agents must validate template compliance before execution.
Template Validation Rules
- All front matter fields must be present and properly formatted
- All section headers must match exactly (case-sensitive)
- All identifier prefixes must follow the specified format
- Tables must include all required columns
- No placeholder text may remain in the final output
Status
The status of the implementation plan must be clearly defined in the front matter and must reflect the current state of the plan. The status can be one of the following (status_color in brackets): Completed (bright green badge), In progress (yellow badge), Planned (blue badge), Deprecated (red badge), or On Hold (orange badge). It should also be displayed as a badge in the introduction section.
---
goal: [Concise Title Describing the Package Implementation Plan's Goal]
version: [Optional: e.g., 1.0, Date]
date_created: [YYYY-MM-DD]
last_updated: [Optional: YYYY-MM-DD]
owner: [Optional: Team/Individual responsible for this spec]
status: 'Completed'|'In progress'|'Planned'|'Deprecated'|'On Hold'
tags: [Optional: List of relevant tags or categories, e.g., `feature`, `upgrade`, `chore`, `architecture`, `migration`, `bug` etc]
---
# Introduction

[A short concise introduction to the plan and the goal it is intended to achieve.]
## 1. Requirements & Constraints
[Explicitly list all requirements & constraints that affect the plan and constrain how it is implemented. Use bullet points or tables for clarity.]
- **REQ-001**: Requirement 1
- **SEC-001**: Security Requirement 1
- **[3 LETTERS]-001**: Other Requirement 1
- **CON-001**: Constraint 1
- **GUD-001**: Guideline 1
- **PAT-001**: Pattern to follow 1
## 2. Implementation Steps
### Implementation Phase 1
- GOAL-001: [Describe the goal of this phase, e.g., "Implement feature X", "Refactor module Y", etc.]
| Task | Description | Completed | Date |
|------|-------------|-----------|------|
| TASK-001 | Description of task 1 | ✅ | 2025-04-25 |
| TASK-002 | Description of task 2 | | |
| TASK-003 | Description of task 3 | | |
### Implementation Phase 2
- GOAL-002: [Describe the goal of this phase, e.g., "Implement feature X", "Refactor module Y", etc.]
| Task | Description | Completed | Date |
|------|-------------|-----------|------|
| TASK-004 | Description of task 4 | | |
| TASK-005 | Description of task 5 | | |
| TASK-006 | Description of task 6 | | |
## 3. Alternatives
[A bullet point list of any alternative approaches that were considered and why they were not chosen. This helps to provide context and rationale for the chosen approach.]
- **ALT-001**: Alternative approach 1
- **ALT-002**: Alternative approach 2
## 4. Dependencies
[List any dependencies that need to be addressed, such as libraries, frameworks, or other components that the plan relies on.]
- **DEP-001**: Dependency 1
- **DEP-002**: Dependency 2
## 5. Files
[List the files that will be affected by the feature or refactoring task.]
- **FILE-001**: Description of file 1
- **FILE-002**: Description of file 2
## 6. Testing
[List the tests that need to be implemented to verify the feature or refactoring task.]
- **TEST-001**: Description of test 1
- **TEST-002**: Description of test 2
## 7. Risks & Assumptions
[List any risks or assumptions related to the implementation of the plan.]
- **RISK-001**: Risk 1
- **ASSUMPTION-001**: Assumption 1
## 8. Related Specifications / Further Reading
[Link to related spec 1]
[Link to relevant external documentation]
Related skills
More from github/awesome-copilot and the wider catalog.
git-commit
Execute semantic git commits with conventional message analysis and intelligent staging.
excalidraw-diagram-generator
Generate Excalidraw diagrams from natural language descriptions.
documentation-writer
Create structured technical documentation using the Diátaxis framework for tutorials, how-to guides, references, and explanations.
gh-cli
GitHub CLI comprehensive reference for repositories, issues, PRs, Actions, projects, releases, and all GitHub operations from the command line.
prd
Generate comprehensive Product Requirements Documents with executive summaries, user stories, technical specs, and risk analysis.
refactor
Surgical code refactoring to improve maintainability without changing behavior.