refactor skill

Overview

This skill suggests refactoring improvements to raise code quality, readability, and maintainability for Kotlin projects. It targets code smells, design issues, performance bottlenecks, and testability gaps, delivering concrete Before/After examples. Use it to get actionable, pattern-driven refactoring suggestions that are easy to review and apply.

How this skill works

Provide the code or describe the problematic module and the project context; the skill inspects method length, duplication, class responsibilities, algorithmic complexity, and adherence to SOLID principles. It returns a Before (current code), an After (refactored code) and a clear list of Improvements Made with explanations and rationale. Recommendations prioritize minimal, testable changes and point out where design patterns or API-level changes are appropriate.

When to use it

• When methods or classes have grown too large or complex
• When multiple places duplicate the same logic
• When code violates SOLID principles or lacks clear responsibilities
• When performance hotspots or inefficient algorithms are suspected
• When unit testing is hard due to tight coupling or poor modularity

Best practices

• Start with automated tests or add characterization tests before large refactors
• Refactor in small steps and commit frequently to keep changes reviewable
• Prefer explicit interfaces and dependency injection for testability
• Replace duplication with well-named abstractions or utility functions
• Document behavioral changes and preserve external contracts unless intentionally breaking

Example use cases

• Extract long Kotlin functions into smaller private functions and domain services
• Replace duplicated parsing logic across modules with a single parser component
• Introduce strategy or factory patterns to simplify conditional chains
• Refactor synchronous blocking I/O to coroutine-based suspend functions for better throughput
• Split large monolithic classes into focused classes following single responsibility

FAQ