New: 97,000+ skills indexed from GitHub repos with 100+ stars · every skill safety-checkedBrowse top skillsTop skills
Esc to closeBrowse all skills
Submit a skillBrowse skills
Submit a skillBrowse skills

Agent skill

Plan Refactor

by danielvm-git in danielvm-git/bigpowers

Create a detailed refactor plan with tiny commits via user interview, then save it as specs/REFACTORLATEST.md.

MITAuto-check passedDevelopment

Install Plan Refactor

skills CLI
$ npx skills add danielvm-git/bigpowers --skill plan-refactor -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install danielvm-git/bigpowers plan-refactor --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/danielvm-git/bigpowers.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/plan-refactor .claude/skills/plan-refactor && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
plan-refactor
GitHub stars
256
Token cost
~829 tokens
SKILL.md length
418 words
Files
1
Skills in repo
39
Repo updated
First seen
Licence
MIT

At a glance

Create a detailed refactor plan with tiny commits via user interview, then save it as specs/REFACTORLATEST.md.

  • Works in 8 steps: Ask the user for a long, detailed… → Explore the repo to verify their… → Ask whether they have considered other… → …
  • User wants to plan a refactor
  • SKILL.md covers Steps, Problem Statement, Solution and Commits, plus 6 more sections
  • Instructions only: no scripts, shell commands, URLs or credentials in SKILL.md

What it does

Plan Refactor is an agent skill from danielvm-git/bigpowers. Create a detailed refactor plan with tiny commits via user interview, then save it as specs/REFACTORLATEST.md. Use when user wants to plan a refactor, create a refactoring RFC, or break a refactor into safe incremental steps.

Its SKILL.md is about 830 tokens, which your agent loads only when the skill is triggered. It is a single SKILL.md file with no bundled scripts.

It sits in Development, covering Refactoring and User research. The repository describes itself as: Agent skills synthesizing years of software engineering discipline into a prescriptive methodology for solo developers. The licence is MIT.

When your agent uses it

  • User wants to plan a refactor
  • Create a refactoring RFC
  • Break a refactor into safe incremental steps

Example prompts

  • “/plan-refactor”

Workflow steps

8 steps, taken from the first numbered list in SKILL.md.

  1. Ask the user for a long, detailed description of the problem they want to solve and any potential ideas for solutions.
  2. Explore the repo to verify their assertions and understand the current state of the codebase.
  3. Ask whether they have considered other options, and present other options to them.
  4. Interview the user about the implementation. Be extremely detailed and thorough.
  5. Hammer out the exact scope of the implementation. Work out what you plan to change and what you plan not to change.
  6. Look in the codebase to check for test coverage of this area. If there is insufficient test coverage, ask the user what their plans for…
  7. Break the implementation into a plan of tiny commits. Remember Martin Fowler's advice: "make each refactoring step as small as possible…
  8. Save the refactor plan to specs/REFACTOR_LATEST.md. Create the specs/ directory if it doesn't exist.

What it can do on your machine

Read from SKILL.md and the folder at commit 812d57a. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    No scripts in the folder and no shell commands in SKILL.md.

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Plan Refactor loads about 829 tokens when it runs. Until then it costs about 60 tokens; SKILL.md has 418 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~60
When it runs · the whole SKILL.md, loaded when a task matches
~829

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from danielvm-git/bigpowers at commit 812d57a, republished under its MIT licence (© danielvm-git). 418 words, ~829 tokens.

Download SKILL.mdSave it as .claude/skills/plan-refactor/SKILL.md (or your agent's skills folder).
name
plan-refactor
description
Create a detailed refactor plan with tiny commits via user interview, then save it as specs/REFACTOR_LATEST.md. Use when user wants to plan a refactor, create a refactoring RFC, or break a refactor into safe incremental steps.
model
sonnet
effort
standard

Plan Refactor

HARD GATE — HARD GATE — Before refactoring, document the current behavior and why it is wrong. Extract one invariant that must be preserved. If you skip this, you will break things you don't expect.

Create a detailed refactor plan through a user interview. Save output to specs/REFACTOR_LATEST.md.

Steps

  1. Ask the user for a long, detailed description of the problem they want to solve and any potential ideas for solutions.

  2. Explore the repo to verify their assertions and understand the current state of the codebase.

  3. Ask whether they have considered other options, and present other options to them.

  4. Interview the user about the implementation. Be extremely detailed and thorough.

  5. Hammer out the exact scope of the implementation. Work out what you plan to change and what you plan not to change.

  6. Look in the codebase to check for test coverage of this area. If there is insufficient test coverage, ask the user what their plans for testing are.

  7. Break the implementation into a plan of tiny commits. Remember Martin Fowler's advice: "make each refactoring step as small as possible, so that you can always see the program working."

  8. Save the refactor plan to specs/REFACTOR_LATEST.md. Create the specs/ directory if it doesn't exist.

<refactor-plan-template>

Problem Statement

The problem that the developer is facing, from the developer's perspective.

Solution

The solution to the problem, from the developer's perspective.

Show full SKILL.md (186 more words)Show less

Commits

A LONG, detailed implementation plan. Write the plan in plain English, breaking down the implementation into the tiniest commits possible. Each commit should leave the codebase in a working state.

Each commit entry follows this format:

N. <commit description> → verify: <runnable command>

Decision Document

A list of implementation decisions that were made:

  • The modules that will be built/modified
  • The interfaces of those modules that will be modified
  • Technical clarifications from the developer
  • Architectural decisions
  • Schema changes, API contracts, specific interactions

Do NOT include specific file paths or code snippets. They may end up being outdated very quickly.

Testing Decisions

  • A description of what makes a good test (only test external behavior, not implementation details)
  • Which modules will be tested
  • Prior art for the tests (i.e. similar types of tests in the codebase)

Out of Scope

A description of the things that are out of scope for this refactor.

Further Notes (optional)

Any further notes about the refactor.

</refactor-plan-template>

After writing specs/REFACTOR_LATEST.md, suggest running kickoff-branch next to create a refactor branch.

References

<!-- story: e35s10 -->

Verify

© danielvm-git, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

Just SKILL.md in skills/plan-refactor of danielvm-git/bigpowers.

Open the folder on GitHubat commit 812d57a

Compare with similar skills

Plan Refactor next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Plan Refactor compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Plan Refactor this skilldanielvm-git/bigpowers256—~829Automated safety check: PassMIT
Request Refactor Planfossasia/eventyay-interpretation1.6k10 repos~678Automated safety check: PassApache-2.0
Guidelinesakash-network/node1.1k22 repos~577Automated safety check: PassMIT
Component Refactoringlangflow-ai/langflow156k—~3.5kAutomated safety check: PassMIT
Migrate Core Code to Submodulestinyhumansai/openhuman41k—~2.6kAutomated safety check: PassGPL-3.0
ast-grep Structural Searchcode-yeongyu/oh-my-openagent70k—~3.3kAutomated safety check: PassMIT

Similar skills

  • Request Refactor Plan

    fossasia/eventyay-interpretation

    Create a detailed refactor plan with tiny commits via user interview, then file it as a GitHub issue.

    1.6k GitHub starsUsed in 10 repos~678 tokens
    DevelopmentAuto-check passed

  • Guidelines

    akash-network/node

    Behavioral guidelines to reduce common LLM coding mistakes. An agent skill from akash-network/node.

    1.1k GitHub starsUsed in 22 repos~577 tokens
    DevelopmentAuto-check passed

  • Component Refactoring

    langflow-ai/langflow

    Refactor high-complexity React components in Langflow frontend.

    156k GitHub stars~3.5k tokensUpdated today
    DevelopmentAuto-check passed

  • Migrate Core Code to Submodules

    tinyhumansai/openhuman

    Plans and carries out moving non-host-specific code and its tests from the OpenHuman core into vendored tiny submodule libraries, then releases the submodule and re-pins the host.

    41k GitHub stars~2.6k tokensUpdated yesterday
    DevelopmentAuto-check passed

  • ast-grep Structural Search

    code-yeongyu/oh-my-openagent

    Searches and rewrites code by syntax-tree shape across 25 languages with ast-grep, for codemods, structural queries and YAML lint rules, using a Python wrapper script.

    70k GitHub stars~3.3k tokensUpdated today
    DevelopmentAuto-check passed

  • Systematic Code Refactoring

    luongnv89/claude-howto

    Guides refactoring in phases based on Martin Fowler's method: research, test coverage check, planning and small tested steps, with your approval at each phase.

    42k GitHub stars~3k tokensUpdated 7 days ago
    DevelopmentAuto-check passed

More from danielvm-git/bigpowers

All 39 skills in this repo

  • Extract Design

    danielvm-git/bigpowers

    Extract a Google DESIGN.md file from an HTML prototype (claude.ai/design or any styled page) using Puppeteer, producing machine-readable tokens and AI-generated prose.

    256 GitHub stars~1k tokensUpdated 16 days ago
    Auto-check passed

  • Align Grid

    danielvm-git/bigpowers

    Build editorial/magazine/report webpages on a GENUINE Müller-Brockmann modular grid (International Typographic Style) — not a decorative one.

    256 GitHub stars~3k tokensUpdated 16 days ago
    Auto-check passed

  • Assess Impact

    danielvm-git/bigpowers

    Analyze the blast radius of a proposed change before any code is written.

    256 GitHub stars~766 tokensUpdated 16 days ago
    Auto-check passed

  • Audit Code

    danielvm-git/bigpowers

    Self-review checklist for the coding agent to run before dispatching a reviewer.

    256 GitHub stars~1.6k tokensUpdated 16 days ago
    Auto-check: notes

  • Audit Plan

    danielvm-git/bigpowers

    Evaluate an incoming project plan against bigpowers principles and conventions, surface gaps, and produce a READY/NOT READY verdict before engagement begins.

    256 GitHub stars~880 tokensUpdated 16 days ago
    Auto-check passed

  • Compose Workflow

    danielvm-git/bigpowers

    Chain multiple bigpowers skills into a custom workflow recipe saved in specs/.

    256 GitHub stars~723 tokensUpdated 16 days ago
    Auto-check passed

Categories

Questions about Plan Refactor

What does Plan Refactor do?

Create a detailed refactor plan with tiny commits via user interview, then save it as specs/REFACTORLATEST.md. Plan Refactor is an agent skill from danielvm-git/bigpowers.md.

When should I use Plan Refactor?

Plan Refactor fits situations like: user wants to plan a refactor; create a refactoring RFC; break a refactor into safe incremental steps.

How do I install Plan Refactor in Claude Code?

Run `npx skills add danielvm-git/bigpowers --skill plan-refactor -a claude-code`. Or copy the skill folder (skills/plan-refactor in danielvm-git/bigpowers) into .claude/skills/plan-refactor in your project. Claude Code loads it when a task matches its description.

How do I install Plan Refactor in Codex?

Run `npx skills add danielvm-git/bigpowers --skill plan-refactor -a codex`. Or copy the skill folder (skills/plan-refactor in danielvm-git/bigpowers) into .agents/skills/plan-refactor in your project. Codex loads it when a task matches its description.

Can I use Plan Refactor in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add danielvm-git/bigpowers --skill plan-refactor -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/plan-refactor, .gemini/skills/plan-refactor, .github/skills/plan-refactor and .opencode/skills/plan-refactor in your project.

What does Plan Refactor need to run?

SKILL.md names no scripts, command-line tools or credentials: Plan Refactor is instructions for the agent only.

Does Plan Refactor access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is Plan Refactor safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Plan Refactor use?

Plan Refactor is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Plan Refactor use?

About 829 tokens (SKILL.md is roughly 3.3k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Plan Refactor?

Skills that share tags, products or a category with Plan Refactor: Request Refactor Plan (fossasia/eventyay-interpretation, 1.6k stars), Guidelines (akash-network/node, 1.1k stars), Component Refactoring (langflow-ai/langflow, 156k stars) and Migrate Core Code to Submodules (tinyhumansai/openhuman, 41k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Plan Refactor?

danielvm-git (a GitHub user) maintains it in danielvm-git/bigpowers, which has 256 GitHub stars. The repository holds 39 skills in this directory. The repository was last updated on September 21, 2026.

Source: danielvm-git/bigpowers on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.