refactoring-suggester_skill

Overview

This skill suggests concrete refactorings to improve code structure, readability, and maintainability. It identifies common opportunities like method extraction, renaming, duplication removal, conditional simplification, and replacing magic values. Use it to get prioritized, actionable refactor ideas rather than full automated rewrites. Recommendations focus on lowering complexity and making intent clearer.

How this skill works

The skill analyzes code patterns and flags smells such as long functions, repeated logic, nested conditionals, and unnamed constants. For each issue it proposes specific refactor types (e.g., Extract Method, Replace Magic Numbers, Simplify Conditionals) and shows example transformations. Suggestions include small, verifiable steps and rationale so you can apply them incrementally and safely. It highlights low-risk changes first and calls out areas where tests or design changes are needed.

When to use it

• Before or during a cleanup sprint to reduce technical debt
• When code reviews repeatedly surface the same structure problems
• Prior to adding features to fragile, complex modules
• When preparing code for easier testing or onboarding new developers
• If you see repeated blocks or long functions that are hard to follow

Best practices

• Apply one refactoring at a time and run tests after each change
• Prefer small, intent-revealing names when renaming variables or methods
• Extract cohesive pieces of logic into well-named functions to document intent
• Replace magic numbers with named constants or configuration values
• Use lookup tables or strategy objects to simplify complex branching

Example use cases

• Split a 200-line function into smaller methods to improve readability and reuse
• Consolidate duplicated validation logic into a shared utility
• Replace hard-coded discount rates or thresholds with named constants and a single source of truth
• Convert nested if/else chains into guard clauses or a lookup table for clearer flow
• Recommend applying a design pattern (e.g., Strategy, Factory) when multiple conditionals indicate divergent behaviors