request-refactor-plan

Generate an interview-informed refactor plan and file it as a GitHub issue.

1|Updated May 5, 2026
One-click install
npx skills add https://github.com/yashs33244/my-mac-claude --skill request-refactor-plan-yashs33244
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: request-refactor-plan
Source: https://github.com/yashs33244/my-mac-claude/tree/main/skills/mattpocock/deprecated/request-refactor-plan
Command: npx skills add https://github.com/yashs33244/my-mac-claude --skill request-refactor-plan-yashs33244

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

It helps you translate a vague refactor desire into a clear, actionable refactoring plan you can execute safely, using an interview-driven approach and then documenting the outcome as a GitHub issue.

Core Features & Use Cases

  • User-interview-driven scope: Gathers the problem context, desired outcomes, constraints, and implementation assumptions before planning the work.
  • Repo verification and options: Checks the repository state to validate claims and considers alternative approaches to reduce risk.
  • Tiny-commit execution plan: Produces a commit-by-commit plan aligned to Martin Fowler’s guidance so each step keeps the codebase working.
  • Issue-ready deliverable: Writes the plan in a structured GitHub issue template, including decisions, testing, and explicit out-of-scope items.
  • Use case: When you want to refactor a subsystem (e.g., improving architecture or simplifying modules) without breaking functionality, this skill structures the work into incremental changes and produces an issue ready for implementation and review.

Quick Start

Ask for a refactor plan by saying: “Create a detailed refactor plan for my codebase by interviewing me about the current behavior and goals, verifying the repo, proposing alternatives, breaking the refactor into tiny commits, and filing it as a GitHub issue.”

Frequently Asked Questions about request-refactor-plan

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I break a large codebase refactor into safe, incremental commits?

To break a large codebase refactor into safe incremental commits, you generate a commit-by-commit plan aligned with Martin Fowler's guidance, ensuring each step preserves functionality. This structures refactoring into low-risk, tiny changes across the target code area.

What is an interview-informed refactoring plan?

An interview-informed refactoring plan is a structured strategy that gathers problem context, desired outcomes, constraints, and implementation assumptions before planning the work. It validates repository state and proposes alternatives to reduce risk before decomposing the refactor.

How do I create a refactoring RFC as a GitHub issue?

Creating a refactoring RFC as a GitHub issue involves documenting a structured refactor plan with dedicated sections for decisions, testing strategy, and explicit out-of-scope items. The issue-ready deliverable captures the incremental change sequence for implementation and review.

How do I define scope and out-of-scope items for a module refactor?

Defining scope and out-of-scope items for a module refactor requires an interview-driven approach to gather explicit context and constraints. The resulting plan documents out-of-scope items in structured GitHub issue sections to maintain strict boundaries during implementation.

Can I verify repository state before proposing a refactor plan?

Yes, verifying repository state before proposing a refactor plan is a core requirement. The planning process checks the repository to validate claims, considers alternative approaches to reduce risk, and sequences tiny commits that preserve functionality throughout the refactoring effort.

What is the best way to plan an incremental architecture change without breaking functionality?

The best way to plan an incremental architecture change without breaking functionality is to use a tiny-commit execution plan. It sequences refactoring steps so the codebase keeps working after each change, applying Martin Fowler's guidance to maintain continuous functionality.