Create Implementation Plan
Install this skill when you need a deterministic, file-based implementation plan for a feature, refactor, package upgrade, or architecture change before agents execute work.
Overview
create-implementation-plan is an agent skill most often used in Validate (also Build, Ship) that produces structured, executable implementation plan files for features, refactors, upgrades, and architecture work.
Install
npx skills add https://github.com/github/awesome-copilot --skill create-implementation-planWhat is this skill?
- Primary directive: machine-readable plans for autonomous AI or human execution
- Requires discrete atomic phases with measurable completion criteria
- Tasks must include concrete file paths, function names, and exact implementation details
- Supports parallel tasks within phases unless dependencies are declared
- Covers new features, refactoring, package upgrades, design, architecture, and infrastructure
Adoption & trust: 10.9k installs on skills.sh; 34.6k GitHub stars; 2/3 security scanners passed (skills.sh audits).
What problem does it solve?
You have a vague goal but no ordered, file-specific plan that another agent can execute without asking clarifying questions.
Who is it for?
Solo builders planning non-trivial features, refactors, or infrastructure changes who want plans optimized for literal agent execution.
Skip if: One-line bugfixes or tasks where a single PR description is enough and formal phased planning would slow you down.
When should I use this skill?
Creating a new implementation plan for new features, refactoring existing code, upgrading packages, or design, architecture, or infrastructure changes.
What do I get? / Deliverables
A new implementation plan document with phased, atomic tasks, completion criteria, and explicit paths—ready to drive Build work or hand off to execution skills.
- Implementation plan file with atomic phases and executable tasks
- Measurable completion criteria per phase
Recommended Skills
Journey fit
Spans multiple journey phases - primary shelf plus alternate fits below.
Canonical shelf is Validate/scope because the skill’s primary output is scoping and sequencing work before heavy Build execution. Scope subphase is where bounded plans, phases, and task lists are produced so build and ship steps have explicit acceptance criteria.
Where it fits
Define phased tasks and completion gates before approving a greenfield feature.
Split an approved spec into parallel agent tasks with explicit file and function targets.
Document an infrastructure or package upgrade rollout with ordered phases and measurable exit criteria.
How it compares
Use instead of free-form chat planning when you need a durable plan artifact on disk, not a ephemeral thread summary.
Common Questions / FAQ
Who is create-implementation-plan for?
Indie developers and agent-first workflows that need deterministic implementation plans before coding or deploying.
When should I use create-implementation-plan?
In Validate (scope) before committing to build; in Build (pm) when breaking a spec into agent tasks; in Ship (launch) when planning release or infra migrations with phased rollout criteria.
Is create-implementation-plan safe to install?
The skill instructs planning output only; confirm behavior in your repo and check the Security Audits panel on this Prism page before use.
SKILL.md
READMESKILL.md - Create Implementation Plan
# 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 ## 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. ```md --- 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 ![Status: <status>](https://img.shields.io/badge/status-<status>-<status_color