Results for “safe-refactoring”

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

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

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.

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

Refactors Swift code toward declarative functional programming with immutability, value types, pure functions, transformations, and closure-based APIs.

Refactors test files to improve behavioral coverage, clarity, structure, assertions, fixture setup, and mocking strategy, removing implementation-detail or low-value tests.

Plan and execute large refactor or rewrite efforts efficiently with parallel multi-agent analysis and implementation.

Refactors a class toward the Single Responsibility Principle by identifying responsibilities, grouping cohesive behavior, and extracting focused classes.

Refactors production code with test coverage using a TDD workflow that applies approved refactorings one at a time, gates each on passing tests, and commits or reverts accordingly.

Resolves legacy references to the refactor-cleaner capability by routing to the current runtime equivalent, such as an agent or modern skill.

Refactors code by removing unused imports, variables, methods, redundant comments, and fixing formatting, with automatic test runs and commits after each step.

Splits, merges, moves, or deletes code while preserving behavior, tests, contracts, and boundaries, with characterization evidence and reversible steps.

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

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

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

Runs three parallel reviewers to find code reuse, quality, and efficiency issues in a diff, then applies safe fixes and reports risky ones.

Safely change and test untested codebases using techniques from Feathers' 'Working Effectively with Legacy Code': seams, characterization tests, sprout/wrap, and dependency-breaking.

Finds and safely removes dead code across a codebase: unreachable paths, unused exports, functions, variables, CSS selectors, dependencies, env vars, and commented-out blocks. Builds an import graph, verifies no dynamic references, and runs build and tests after cleanup.