create-implementation-plan
Lets your agent plan how to implement new features. It creates a detailed plan to organize development work.
What it does
This agent creates a detailed plan for implementing new features, updating existing code, or making system improvements. It ensures the plan is clear and easy to follow by other AI tools or people.
When to use it
- ✓When planning to add a new feature to a software.
- ✓When deciding to update packages or libraries in a project.
- ✓When designing changes to a system's architecture or infrastructure.
Example of what to ask your AI
“Create an implementation plan to add two-factor authentication to the login module.”
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
It uses a specific format and clear rules to describe each step. Each step is detailed with file paths, function names, and exact instructions, leaving no room for ambiguity.
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 create-implementation-planOr download just the file:
curl -L https://raw.githubusercontent.com/github/awesome-copilot/main/skills/create-implementation-plan/SKILL.md -o SKILL.mdTechnical content (original SKILL.md)
Original text by the author, straight from GitHub.
Create Implementation Plan
Primary Directive
Your goal is to create a new implementation plan file for ${input:PlanPurpose}. 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
- Identifiers must be uniquely declared. Every identifier (
REQ-NNN,SEC-NNN,CON-NNN,GUD-NNN,PAT-NNN,GOAL-NNN,TASK-NNN,ALT-NNN,DEP-NNN,FILE-NNN,TEST-NNN,RISK-NNN,ASSUMPTION-NNN) must be declared exactly once. A declaration is where the identifier introduces a row: the leading cell in a TASK/GOAL table row, or the bolded prefix in a bullet line like- **REQ-001**: .... The same identifier may then appear any number of times as a reference elsewhere in the plan (aTASKbody citing aREQ, oneTASKciting anotherTASK, the Dependencies section pointing at aDEPalready declared upstream, etc.). References are expected and not collisions.
Identifier Uniqueness Check
Run these checks before finalizing the plan. Checks (1) and (2) target declarations and must return zero rows. Check (3) is a broad informational scan: it will surface valid references too, so use it for awareness rather than as a gate.
# Set PLAN_FILE to the plan being validated.
PLAN_FILE="/plan/<purpose>-<component>-<version>.md"
# 1) Duplicate TASK / GOAL declarations in table rows.
grep -oE '\| (TASK|GOAL)-[0-9]+ \|' "$PLAN_FILE" \
| sed -E 's/.*((TASK|GOAL)-[0-9]+).*/\1/' \
| sort | uniq -d
# 2) Duplicate declaration IDs in bullet-style spec lines.
grep -oE '^- \*\*(REQ|SEC|CON|GUD|RISK|ASSUMPTION|TASK|GOAL|FILE|TEST|PAT|ALT|DEP)-[0-9]+\*\*:' "$PLAN_FILE" \
| sed -E 's/^- \*\*([A-Z]+-[0-9]+)\*\*:.*/\1/' \
| sort | uniq -d
# 3) Broad duplicate scan (diagnostic only; may include valid references).
…
FAQ
What are 'unique identifiers'?
These are codes like REQ-001 or TASK-005 that identify each requirement or task. Each one must appear only once to avoid confusion.
Why does the plan need to be 'machine-readable'?
This means the plan is written in a way that other AI tools can understand and execute it automatically, making the process faster and more efficient.
What does 'discrete, atomic phases' mean?
The plan is divided into small parts (phases) that can be worked on independently, and each part contains well-defined (atomic) tasks that are easy to execute.
Details
Original description by the author
Create a new implementation plan file for new features, refactoring existing code or upgrading packages, design, architecture or infrastructure.
repo: github/awesome-copilot
Popularity
- GitHub stars
- 40k
- Ranking position
- #5082
- 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
intent-driven-development
Helps your agent turn ideas into clear, testable plans. Defines criteria to ensure changes are made correctly and safely.
affaan-m/ECC
product-capability
Guides your agent in turning product ideas into clear plans. It defines what needs to be done, the limits, and decisions before development.
affaan-m/ECC
article-writing
Writes long-form content like articles, guides, and blog posts with a unique style. It's useful when you need well-written texts with a consistent voice and credibility.
affaan-m/ECC