Skip to content
Skills Library
Programming · Building & coding

refactor

/refactor

Behavior-preserving code refactoring. Use when the user asks to simplify complex or duplicated code, improve naming, control flow, or module structure, extract code, or clean up an implementation without changing functionality. Preserve public APIs unless the user explicitly authorizes a change.

Repository
Skills ↗
Licence
MIT
Last repository change
25.10.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 25.10.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Behavior-preserving code refactoring. Use when the user asks to simplify complex or duplicated code, improve naming, control flow, or module structure, extract code, or clean up an implementation without changing functionality. Preserve public APIs unless the user explicitly authorizes a change.

Original author description

Behavior-preserving code refactoring. Use when the user asks to simplify complex or duplicated code, improve naming, control flow, or module structure, extract code, or clean up an implementation without changing functionality. Preserve public APIs unless the user explicitly authorizes a change.

How it works

  1. Process
  2. Report
Original SKILL.md headings · 63 lines, 393 words
SKILL.md preview
---
name: refactor
description: >-
  Behavior-preserving code refactoring. Use when the user asks to simplify
  complex or duplicated code, improve naming, control flow, or module structure,
  extract code, or clean up an implementation without changing functionality.
  Preserve public APIs unless the user explicitly authorizes a change.
---

# Refactor

Make the smallest structural change that produces a specific improvement while preserving the
code's observable contract.

## Process

### 1. Define the contract and target

Read applicable project guidance, the target code, its callers, and nearby tests. Name one
structural target, such as duplicated decisions, nested control flow, mixed responsibilities,
unclear ownership, or misleading names. Record the behavior that must remain stable: public APIs,
outputs, side effects, error behavior, ordering, and any performance-sensitive invariant.

Completion: the target improvement is checkable, the preserved contract is explicit, and affected
callers are accounted for.

### 2. Establish preservation evidence

Run the narrowest existing checks that exercise the contract. When coverage is missing, add or
record a focused characterization check for the behavior at risk. Resolve ambiguous behavior with
the user before changing it. Treat a discovered bug, API change, dependency change, or architectural
choice as separate work requiring approval.

Completion: the baseline result is captured, every behavior at risk has a repeatable check or a
reported coverage gap, and ambiguities are resolved or excluded from scope.

### 3. Apply one coherent simplification

Keep the change centered on the named structural target. Choose only the techniques it needs:

- flatten control flow or make the happy path explicit;
- remove genuine duplication or dead code;
- rename concepts to match their role;
- extract a cohesive function, type, or module;
- replace an awkward data structure with one that expresses the invariant.

Follow local conventions and keep public APIs, dependencies, and architectural boundaries stable.
Supporting renames or extractions belong in the same change only when they serve the target.

Completion: the target is measurably improved and every changed line supports that improvement or
preserves its contract.

### 4. Verify the contract

Repeat the baseline checks and run the repository's relevant typecheck, tests, lint, or build.
Inspect the final diff and affected callers for accidental behavior or API changes. Compare the
before and after using the target's evidence: fewer branches, less duplication, narrower ownership,
clearer names, or a smaller public surface.

Completion: relevant checks pass, or unrelated failures are reported with evidence; compatibility
is confirmed; and the improvement is demonstrated by a specific before/after comparison.

## Report

State:

- the structural target and what changed;
- the preservation evidence and commands run;
- the concrete before/after improvement;
- unresolved coverage gaps, assumptions, or separately scoped opportunities.

Versions

RepositoryScoreLicence
This page · kriscard/Skills100MIT
froglet-studio/cosmic-shore100MIT
mgiovani/cc-arsenal100MIT
jongio/skills100MIT
boshu2/agentops100Apache-2.0
y-miyazaki/terraform-aws-base100Apache-2.0
mickeyyaya/evolve-loop100Apache-2.0
j0hanz/j0hanz-marketplace100MIT
kriscard/kriscard-claude-plugins100MIT

Database snapshot: 13.11.2026 · package version de94dd91b9db (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100refactor-clean
    Use when code has grown complex, duplicated, or cluttered — clean up structure and remove dead code without changing observable behavior
  • 100refactoring-specialist
    Use when you need to transform poorly structured, complex, or duplicated code into clean, maintainable systems while preserving all existing behavior.
  • 95simplify
    Use when the user wants to simplify or clean up code without changing behavior. Accepts standalone scope or user-selected findings from /refactor.
  • 100refactoring-specialist
    Use when you need to transform poorly structured, complex, or duplicated code into clean, maintainable systems while preserving all existing behavior.
  • 100code-refactoring
    Simplify and refactor code while preserving behavior, improving clarity, and reducing complexity. Use when simplifying complex code, removing duplication, or applying design patterns. Handles Extract Method, DRY principle, SOLID principles, behavior validation, and refactoring patterns.
  • 100acp-refactor
    Use when the user asks to refactor, clean up, simplify, modularize, deduplicate, rename, or improve the structure of existing code WITHOUT changing behavior. If the user wants new behavior, do not use this skill. Enforces small reversible steps and behavior preservation.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.