Results for “safe-refactoring”

Guides incremental code improvements, error-proofing through types and validation, and standardization for higher code quality.

Enforce idiomatic Rust patterns for ownership, error handling, enums, traits, concurrency, and best practices to build safe, performant applications.

Guides incremental code improvements, error-proofing through types and validation, and standardization for higher quality and fewer defects.

Rename Pharo methods safely through Genie's `rename_method` MCP refactoring tool. Use when a selector should be renamed while preserving behavior, updating senders and symbol references across the live image, including as one step in larger refactorings such as clarify API names, split responsibilities, or move behavior behind better messages.

Reviews a codebase for structural smells and refactors them with provable safety, using micro commits and green-bar discipline.

Write idiomatic C++ code with modern features, RAII, smart pointers, and STL algorithms. Handles templates, move semantics, and performance optimization. Use PROACTIVELY for C++ refactoring, memory safety, or complex C++ patterns.

Write idiomatic C++ code with modern features, RAII, smart pointers, and STL algorithms. Handles templates, move semantics, and performance optimization. Use PROACTIVELY for C++ refactoring, memory safety, or complex C++ patterns.

Use when the user wants to rename, extract, split, move, or restructure code safely. Examples: "Rename this function", "Extract this into a module", "Refactor this class", "Move this to a separate file"

Refactor legacy codebases, migrate outdated frameworks, and implement gradual modernization. Handles technical debt, dependency updates, and backward compatibility. Use PROACTIVELY for legacy system updates, framework migrations, or technical debt reduction.

Safe refactor planning for Nick's codebases. Use when planning large refactors, reducing blast radius, sequencing cleanup work, or deciding how to improve messy code without breaking product velocity.

Surgical code refactoring to improve maintainability without changing behavior. Covers extracting functions, renaming variables, breaking down god functions, improving type safety, eliminating code smells, and applying design patterns. Less drastic than repo-rebuilder; use for gradual improvements.

Improve code structure and readability without changing external behavior through surgical refactoring techniques.

Surgical code refactoring to improve maintainability without changing behavior. Covers extracting functions, renaming variables, breaking down god functions, improving type safety, eliminating code smells, and applying design patterns. Less drastic than repo-rebuilder; use for gradual improvements.

Executes automated refactoring for specific files, directories, or semantic queries. This skill should be used when the user asks to refactor specific files or directories, simplify recently changed code, clean up dead code in a limited scope, or invokes "/refactor".

Composite skill — safely refactor a module end-to-end with sequencing, parallel implementation, post-refactor cleanup, and rationale capture. Chains refactor-plan (phased plan + rollback) → three-man-team (architect/builder/reviewer in parallel) → fix-the-suite post-refactor → adr-write → docs-sync. Use for non-trivial refactors that need both careful sequencing and durable record.

Improve code quality and maintainability through systematic identification of code smells and application of proven refactoring patterns. Use when the user requests refactoring or provides relevant inputs for this workflow.

Executes automated project-wide refactoring with a focus on cross-file optimization. This skill should be used when the user asks for project-wide refactoring, cross-file simplification, consistency standardization across the codebase, duplication reduction, or invokes "/refactor-project".

Improves structure without behavior changes, using tests and focused slices; not for features unless behavior change is explicit.

Modernizes legacy scripts (bash, Node, Python) by replacing deprecated APIs, adding error handling, converting callbacks to async/await, and improving maintainability. Turns brittle one-off scripts into reliable, documented tools.

Refactoring Analyst

Review git diffs or file scopes for code reuse, quality, efficiency, and clarity issues, then optionally apply safe, behavior-preserving fixes.

Use when the user wants to rename, extract, split, move, or restructure code safely. Examples: "Rename this function", "Extract this into a module", "Refactor this class", "Move this to a separate file"

Plan a multi-file refactor with proper sequencing and rollback steps

Guide for refactoring code to improve quality without changing behavior. Use when refactoring, cleaning up code, reducing duplication, improving readability, or restructuring code. Integrates Firecrawl for researching modern patterns before refactoring, and codebase-aware dependency analysis to avoid breaking changes.

Review and refactor code according to project-specific coding guidelines and instructions.

Reduces cognitive complexity of a specified method by extracting logic into focused helper methods, improving readability and maintainability.

Creates a concrete, multi-phase plan before starting a multi-file refactor, including affected files, dependencies, verification steps, and rollback procedures.

Restructure existing code without changing its behavior, through a test-gated refactoring loop: a named target, a green suite over that target before any edit, a planned sequence of small named refactorings, and the full suite re-run after every step. Use when the user wants to refactor, restructure, clean up, simplify, or improve the design of existing code, or to apply refactoring recommendations from a code-review or architectural-analysis report. This skill changes code; it does not review code (use code-review), assess architecture (use architectural-analysis), or build new behavior test-first (use tdd). Do not use it on code inside an active tdd loop; the refactor step of tdd owns that cleanup. Runs its planned sequence to completion without pausing for review; to review each named refactoring as it lands, use pairing.

Refactors code for better readability, performance, and maintainability

Refactors code by renaming variables, methods, classes, and types to improve clarity and intent, with automatic testing and commits after each rename.