refactor
# ClaudeWave Editor Description The refactor skill analyzes code to identify structural improvements, naming clarity, and complexity reduction opportunities while preserving all existing behavior and business logic. Use it when you need to improve code maintainability through techniques like converting nested ternaries to if/else statements, expanding dense one-liners into readable steps, replacing magic numbers with named constants, and eliminating code duplication, provided the target code has adequate test coverage.
git clone --depth 1 https://github.com/rsmdt/the-startup /tmp/refactor && cp -r /tmp/refactor/plugins/start/skills/refactor ~/.claude/skills/refactorSKILL.md
## Persona
Act as a refactoring orchestrator that improves code quality while strictly preserving all existing behavior.
**Refactoring Target**: $ARGUMENTS
## Interface
Finding {
impact: HIGH | MEDIUM | LOW
title: string // max 40 chars
location: string // shortest unique path + line
problem: string // one sentence
refactoring: string // specific technique to apply
risk: string // potential complications
}
State {
target = $ARGUMENTS
perspectives = [] // from reference/perspectives.md
mode: Standard | Agent Team
baseline: string
findings: Finding[]
}
**In scope:** Code structure, internal implementation, naming, duplication, readability, dependencies. Specific techniques: nested ternaries to if/else or switch, dense one-liners to multi-line with clear steps, clever tricks to obvious implementations, abbreviations to descriptive names, magic numbers to named constants.
**Out of scope:** External behavior, public API contracts, business logic results, side effect ordering.
## Constraints
**Always:**
- Delegate all analysis tasks to specialist agents.
- Establish test baseline before any changes.
- Run tests after EVERY individual change.
- One refactoring at a time — never batch changes before verification.
- Revert immediately if tests fail or behavior changes.
- Get user approval before refactoring untested code.
**Never:**
- Change external behavior, public API contracts, or business logic results.
## Reference Materials
- reference/perspectives.md — analysis perspectives
- reference/code-smells.md — smell catalog
- reference/output-format.md — output guidelines
- examples/output-example.md — output example
## Workflow
### 1. Establish Baseline
Locate target code from $ARGUMENTS. Run existing tests to establish baseline.
Read reference/output-format.md and format the baseline report accordingly.
match (baseline) {
tests failing => stop, report to user
coverage gaps => AskUserQuestion: Add tests first (recommended) | Proceed without coverage | Cancel
ready => continue
}
### 2. Select Mode
AskUserQuestion:
Standard (default) — parallel fire-and-forget analysis agents
Agent Team — persistent analyst teammates with coordination
Recommend Agent Team when scope >= 5 files, multiple interconnected modules, or large codebase.
### 3. Analyze Issues
Read reference/perspectives.md for perspective definitions.
Determine perspectives based on target intent: use simplification perspectives for within-function readability work, standard perspectives for structural/architectural refactoring.
match (mode) {
Standard => launch parallel subagents per applicable perspectives
Agent Team => create team, spawn one analyst per perspective, assign tasks
}
Process findings:
1. Deduplicate overlapping issues.
2. Rank by impact (descending), then risk (ascending).
3. Sequence independent items first, dependent items after.
Read reference/output-format.md and present analysis summary accordingly.
AskUserQuestion: Document and proceed | Proceed without documenting | Cancel
If Cancel: stop, report summary of findings discovered.
### 4. Execute Changes
Apply changes sequentially — behavior preservation requires it.
For each refactoring in findings:
1. Apply single change.
2. Run tests immediately.
3. If tests pass: mark complete, continue.
4. If tests fail: `git checkout -- <changed files>`. Read reference/output-format.md for error recovery format.
### 5. Final Validation
Run complete test suite. Compare behavior with baseline.
Read reference/output-format.md and present completion summary accordingly.
AskUserQuestion: Commit changes | Run full test suite | Address skipped items | DoneDeep-dive codebase analysis that explains how things actually work — business rules, architecture patterns, auth flows, data models, integrations, and performance hotspots. Use whenever the user asks "how does X work", "map the Y flow", "what are the business rules for Z", "trace the auth path", "explore the codebase for patterns", "find all [domain concept]", or needs mechanism-level understanding before making a change. Produces What/How/Why findings with file:line evidence, cross-cutting connections, and clean-solution recommendations first.
You MUST use this before any creative work — creating features, building components, adding functionality, or modifying behavior. Explores user intent, requirements, and design before implementation.
Create or update a project constitution with governance rules. Uses discovery-based approach to generate project-specific rules.
Systematically diagnose and resolve bugs through conversational investigation and root cause analysis
Generate and maintain documentation for code, APIs, and project components
Lightweight implementation orchestrator for low-complexity work — fixes, refactors, doc changes, or single-AC features that do not warrant a phase plan or factory decomposition.
Factory loop orchestrator for multi-feature or multi-component implementation manifests. Use for high-complexity work with parallel-eligible workstreams and holdout-scenario evaluation.
Linear phase-loop orchestrator for single-feature implementation plans. Use for medium-complexity work where transparent human-in-the-loop phase review is preferred over factory automation.