create-refactor-rfc_skill

Overview

This skill creates a thorough RFC for a planned code refactor and files it as a GitHub issue. It guides you through problem elicitation, repository inspection, modular design, and an exhaustive set of user-story behaviors needed for reviewers and implementers. The output is a ready-to-review RFC matching the provided template and repository context.

How this skill works

I first ask for a long, detailed description of the problem you want to solve and any solution ideas you already have. I then inspect the repository to identify current code structure, violations of project values, and candidates for deep module extraction. Next I propose major modules to build or modify, interview you about desired changes and test priorities, and produce an RFC that follows the required template. Finally I create a GitHub issue containing the RFC so work can be tracked and reviewed.

When to use it

• You plan a non-trivial refactor that needs shared understanding before implementation.
• You need to extract or redesign core modules into deep, easily testable components.
• You want an exhaustive, review-ready specification of behavior and API changes.
• You must create a single authoritative artifact to drive PRs and implementation.
• You want to collect stakeholder feedback before starting code changes.

Best practices

• Provide a detailed problem description and any existing constraints or alternatives.
• Grant repository access or point to key files so I can analyze current structure.
• Decide in advance which modules require unit tests and which need integration tests.
• Favor extracting deep modules with small, stable interfaces for easier testing.
• Validate the proposed modules and behavior list before I generate the final RFC and issue.

Example use cases

• Refactoring a large reducer/flux store into small, testable state modules.
• Splitting a monolithic service into domain-specific services with clear APIs.
• Converting mixed UI/business logic into presentation and domain layers.
• Rewriting a legacy TypeScript module to improve type safety and testability.
• Standardizing an error-handling approach across multiple packages.