Identify code smells and plan behavior-preserving refactors in TypeScript and Python.
npx skills add https://github.com/saranskumar/anti-slop --skill refactor-saranskumar
Please help me install this Agent Skill. Skill: refactor Source: https://github.com/saranskumar/anti-slop/tree/main/skills/refactor Command: npx skills add https://github.com/saranskumar/anti-slop --skill refactor-saranskumar
Refactoring is the discipline of improving code structure without changing behavior. Every change that makes code easier to read, maintain, or extend, while preserving existing behavior, reduces technical debt and future risk.
Analyze a target module, identify code smells, and propose a safe, incremental refactor plan that preserves behavior.
High-intent search queries and answers about installing and using this skill.
To refactor nested legacy code safely, you must enforce tests before refactoring, then apply clear naming and modularization through incremental changes. This preserves existing behavior while reorganizing large modules into smaller, well-named helpers with cohesive responsibility boundaries.
Identifying code smells and duplication in large TypeScript or Python codebases involves analyzing target modules to detect overly complex logic and repeated patterns. This process targets specific areas for improvement to reduce technical debt while maintaining functionality.
Yes, you can modularize large files across languages like TypeScript and Python. The process targets mid-to-large codebases, splitting complex modules into smaller, cohesive units with clear responsibility boundaries without altering the external behavior.
Yes, enforcing tests before refactoring is a strict requirement. Writing tests first ensures you can safely improve code readability and apply incremental changes while verifying that the existing behavior remains completely preserved throughout the process.
A safe incremental refactor plan is created by analyzing a target module, identifying specific code smells, and proposing step-by-step changes. This methodical approach reduces technical debt and future risk by ensuring each modification preserves behavior.
You should avoid refactoring mid-to-large codebase modules when there are no existing tests to verify behavior. Without test coverage to enforce behavior preservation, making incremental changes or modularizing files introduces significant risk of breaking functionality.
skyoxuDetect the game engine and generate engine-specific test suites.
spiralhouseRun RuboCop and RSpec checks against previous baselines to detect regressions.
YYH211Apply a four-step DRY workflow to eliminate code duplication.
StephanvsEnforce high cohesion, low coupling, and composition-first design in software architecture.
