Now liveThe Skillselion MCP - thousands of ranked skills, loaded into your agent mid-task. No install.Get it →
github avatar

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)
At a glance

refactor-plan capabilities & compatibility

Capabilities
planning · code analysis
Use cases
refactoring
From the docs

What refactor-plan says it does

Identify affected files, ownership boundaries, dependencies, and likely hidden coupling
SKILL.md
npx skills add https://github.com/github/awesome-copilot --skill refactor-plan

Add your badge

Show developers this skill is listed on Skillselion. Paste this into your README.

Listed on Skillselion
Installs12.3k
repo stars37.1k
Security audit3 / 3 scanners passed
Last updatedJuly 28, 2026
Repositorygithub/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

SKILL.mdMarkdownGitHub ↗

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.

Code Review & Qualitybackendfrontend

This week in AI coding

Five minutes, every Monday - the tools, releases and tactics for developers.

unsubscribe anytime.