request-refactor-plan

Interview stakeholders and validate codebases to generate RFC-style GitHub issues with tiny-commit refactor plans.

Updated Mar 24, 2026
One-click install
npx skills add https://github.com/stevenengland/sten-agent-skills --skill request-refactor-plan-stevenengland
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: request-refactor-plan
Source: https://github.com/stevenengland/sten-agent-skills/tree/main/skills/request-refactor-plan
Command: npx skills add https://github.com/stevenengland/sten-agent-skills --skill request-refactor-plan-stevenengland

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This workflow helps teams plan and document safe, incremental refactors by interviewing stakeholders, validating the current codebase, and producing a GitHub issue that outlines a tiny-commit plan.

Core Features & Use Cases

  • Interview-driven scoping: gather requirements, constraints, and success criteria from stakeholders to define a clear refactor goal.
  • Repo exploration and risk assessment: verify the current state of the codebase, identify hotspots, test coverage gaps, and potential rollback points.
  • Tiny-commit plan and RFC generation: break the refactor into the smallest possible steps, each resulting in a working state, and capture details in a structured GitHub issue.
  • Use Case: when planning a large feature rewrite, this capability helps produce a staged, reviewable plan that minimizes risk and improves traceability.

Quick Start

Describe the refactor goal and current constraints, then generate a tiny-commit plan and 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 plan a large-scale codebase refactor safely?

To plan a safe refactor, interview stakeholders to define goals, validate the codebase for test coverage gaps, and break the architecture changes into tiny, testable commits. This minimizes risk and ensures traceability throughout the process.

What is the best way to break down a large architecture rewrite into reviewable steps?

The best way to break down an architecture rewrite is generating an RFC-style GitHub issue that stages the refactor into the smallest possible commits. Each commit results in a working state, improving reviewability and establishing clear rollback points for risk minimization.

How do I assess test coverage gaps before starting a major repository refactor?

Assess test coverage gaps before a repository refactor by exploring the codebase to identify hotspots and potential rollback points. This workflow validates the current state to ensure your incremental refactor plan remains safe and testable.

Can I use this workflow to document RFC-style planning across multiple repositories?

Yes, you can use this workflow for RFC-style planning across repositories where traceability and risk minimization are important. It scopes changes and captures the tiny-commit refactor plan within a structured GitHub issue for stakeholder review.

How do stakeholder interviews improve incremental refactor planning?

Stakeholder interviews improve incremental refactor planning by gathering requirements, constraints, and success criteria to define a clear refactor goal. This interview-driven scoping ensures the tiny-commit plan directly aligns with actual project needs.