Code Refactor

What Is Code Refactor?

Code Refactor is a specialized Claude skill designed to streamline and automate bulk code refactoring operations across entire codebases. Its primary goal is to facilitate systematic changes—such as renaming variables, functions, or entire APIs; replacing legacy patterns; and applying consistent updates across multiple files—while drastically minimizing manual effort and risk of human error. Code Refactor intelligently selects between native and code-execution modes based on the scale of the operation, ensuring both efficiency and accuracy for tasks as small as a single file or as extensive as hundreds of files in a repository.

Why Use Code Refactor?

Modern software development demands rapid iteration, the adoption of new coding standards, and continual adaptation to evolving APIs and best practices. Manual refactoring is not only time-consuming but also highly error-prone, especially when changes must be propagated across large codebases with complex interdependencies. Code Refactor addresses these challenges by providing:

• Consistency: Ensures that refactoring changes—such as renaming an identifier or replacing a deprecated method—are applied identically throughout the codebase, reducing the chance of missed instances or subtle bugs.
• Scalability: Handles both small-scale edits (single files) and massive bulk operations (hundreds of files) with equal ease, switching to execution mode for optimal performance when necessary.
• Speed: Automates tedious search-and-replace tasks, accelerating major codebase overhauls that would otherwise require considerable developer time.
• Safety: Offers context-aware search and verification steps, reducing the risk of unintended changes.

Whether you are modernizing a legacy system, enforcing new naming conventions, or updating API usages, Code Refactor serves as an invaluable tool for efficient and reliable code transformation.

How to Get Started

Getting started with Code Refactor is straightforward. The skill can be invoked directly within a Claude-powered environment, typically in response to user queries such as “rename [identifier] to [new_name] across all files” or “replace all instances of [oldPattern] with [newPattern]”. The system automatically determines the optimal mode based on the number of files involved:

• Native Mode (1-9 files): Uses efficient built-in tools like grep for searching and direct file editing for replacements.
• Execution Mode (10+ files): Delegates the operation to the code-execution skill for significant token savings and faster execution.

Example 1: Renaming a function in a small project

Suppose you want to rename the function getUserData to fetchUserData in a project with three files:

## Step 1:

Find all occurrences
Grep(pattern="getUserData", output_mode="files_with_matches")

## Step 2:

Verify with context (optional)
Grep(pattern="getUserData", output_mode="content", -n=True, -B=2, -A=2)

## Step 3:

Replace in each file
Edit(
  file_path="src/api.js",
  old_string="getUserData",
  new_string="fetchUserData",
  replace_all=True
)

Example 2: Bulk renaming across 50 files

For larger operations, such as renaming oldName to newName in 50 Python files:

from api.code_transform import rename_identifier
result = rename_identifier('.', 'oldName', 'newName', '**/*.py')
## Returns: {'files_modified': 50, 'total_replacements': 247}

This approach uses only ~500 tokens versus ~25,000 tokens with traditional methods.

Key Features

• Bulk Identifier Renaming: Rename variables, functions, classes, or other identifiers throughout multiple files with a single command.
• Pattern Replacement: Replace code patterns, such as deprecated API calls or syntax, consistently across the codebase.
• API Call Updates: Systematically update invocations of an API or method, ideal when upgrading libraries or frameworks.
• Automatic Mode Selection: Seamlessly switches between native and execution modes based on the scope, optimizing for speed and resource usage.
• Contextual Search and Verification: Uses advanced search tools to display surrounding code for validation before making changes.
• Token Efficiency: Especially in execution mode, minimizes token usage by batching operations, making it highly scalable for large codebases.

Best Practices

• Preview Changes: Always review the output of search commands (e.g., with context lines) before applying bulk changes to ensure accuracy.
• Use Clear and Specific Patterns: When replacing or renaming, specify precise patterns to avoid unintended replacements (e.g., using word boundaries when appropriate).
• Version Control Integration: Commit your code before running refactoring operations, so you can easily revert changes if needed.
• Test Thoroughly Post-Refactor: Run your test suite after bulk changes to verify that the refactoring did not introduce regressions.
• Leverage Mode Selection: Allow Code Refactor to choose the optimal mode; manual override is rarely necessary unless you have specialized requirements.

Important Notes

• Scope Awareness: Code Refactor operates within the accessible files in your workspace. Ensure all relevant files are included before initiating bulk operations.
• Pattern Limitations: While powerful, pattern replacement relies on the patterns you provide. Overly broad or ambiguous patterns can lead to unintended changes, so specificity is key.
• Performance: For very large projects, execution mode is highly efficient, but the initial indexing may take time. Monitor the reported results to confirm all intended files were modified.
• Manual Review: Automated tools accelerate refactoring but do not replace the need for code review. Always inspect critical changes, especially in production code.
• Supported Languages: While compatible with most text-based code, language-specific nuances (such as context-sensitive keywords) may require tailored patterns for best results.

By integrating Code Refactor into your development workflow, you can confidently execute wide-ranging refactoring tasks with speed, precision, and minimal manual intervention.