
Refactor Plan
- 12.3k installs
- 37.1k repo stars
- Updated July 28, 2026
- github/awesome-copilot
refactor-plan is a skill creating detailed, safe execution plans for multi-file refactoring before implementation.
About
refactor-plan creates detailed refactor execution plans before any code changes. It analyzes codebase scope, identifies affected files and ownership boundaries, sequences changes safely (types first, then implementations, then callers), and includes verification steps and rollback plans. Developers use it to plan multi-file refactors with confidence and minimize risk.
- Creates concrete multi-phase refactor plans with affected files and dependencies
- Includes verification steps and rollback recovery procedures between phases
- Requires plan approval before implementation; avoids blind refactoring
Refactor Plan by the numbers
- 12,334 all-time installs (skills.sh)
- +183 installs in the week ending Jul 28, 2026 (Skillselion tracking)
- Ranked #24 of 1,382 Code Review & Quality skills by installs in the Skillselion catalog
- Security screen: MEDIUM risk (skills.sh audit)
- Data as of Jul 28, 2026 (Skillselion catalog sync)
refactor-plan capabilities & compatibility
- Capabilities
- planning · code analysis
- Use cases
- refactoring
What refactor-plan says it does
Identify affected files, ownership boundaries, dependencies, and likely hidden coupling
npx skills add https://github.com/github/awesome-copilot --skill refactor-planAdd your badge
Show developers this skill is listed on Skillselion. Paste this into your README.
| Installs | 12.3k |
|---|---|
| repo stars | ★ 37.1k |
| Security audit | 3 / 3 scanners passed |
| Last updated | July 28, 2026 |
| Repository | github/awesome-copilot ↗ |
What it does
refactor-plan creates detailed refactor execution plans before any code changes. It analyzes codebase scope, identifies affected files and ownership boundaries, sequences changes safely (types first,
Who is it for?
Teams executing large refactors, type system migrations, or dependency restructuring
Skip if: Single-file changes or trivial refactors
When should I use this skill?
Planning a multi-file refactor, renaming, restructuring, or dependency updates across the codebase
What you get
Detailed refactor plan with phases, affected files, dependencies, verification steps, and rollback procedures
- Sequenced refactor plan
- Affected-files and dependency map
Files
Refactor Plan
Create a detailed plan before making any code changes.
Instructions
1. Do not edit files while preparing the plan. 2. Search the codebase to understand the current state. Read enough implementation, tests, configuration, and docs to make the plan specific to the repository. 3. Identify affected files, ownership boundaries, dependencies, and likely hidden coupling. 4. Plan changes in a safe sequence. Prefer contracts and types first, then implementations, then callers, then tests, then cleanup. 5. Include verification steps between phases and a final validation command. 6. Include rollback or recovery steps for the riskiest phases. 7. Output the complete plan using the format below. 8. Stop after the plan and ask for confirmation before implementing. If the user already asked you to implement, still produce the plan first and wait for confirmation unless they explicitly said to continue without review after the plan.
If the request is too ambiguous to plan safely, ask concise clarifying questions instead of editing files.
Output Format
## Refactor Plan: [title]
### Current State
[Brief description of how things work now]
### Target State
[Brief description of how things will work after]
### Affected Files
| File | Change Type | Dependencies |
|------|-------------|--------------|
| path | modify/create/delete | blocks X, blocked by Y |
### Execution Plan
#### Phase 1: Types and Interfaces
- [ ] Step 1.1: [action] in `file.ts`
- [ ] Verify: [how to check it worked]
#### Phase 2: Implementation
- [ ] Step 2.1: [action] in `file.ts`
- [ ] Verify: [how to check]
#### Phase 3: Tests
- [ ] Step 3.1: Update tests in `file.test.ts`
- [ ] Verify: Run `npm test`
#### Phase 4: Cleanup
- [ ] Remove deprecated code
- [ ] Update documentation
### Rollback Plan
If something fails:
1. [Step to undo]
2. [Step to undo]
### Risks
- [Potential issue and mitigation]After the plan, ask: "Shall I proceed with Phase 1?"
Related skills
How it compares
Use refactor-plan before large structural edits; use lint or security review skills when the change set is small and correctness—not sequencing—is the risk.
FAQ
Does refactor-plan edit code automatically?
refactor-plan forbids file edits while planning; the agent investigates the repository, outputs a sequenced refactor plan, and waits for explicit developer confirmation before changing code.
What does refactor-plan investigate first?
refactor-plan searches the codebase and reads implementation, tests, configuration, and documentation to identify affected files, boundaries, dependencies, and hidden coupling before listing steps.
Is Refactor Plan safe to install?
skills.sh reports 3 of 3 security scanners passed. Review the Security Audits panel on this page before installing in production.