AI Prompts for Claude for Refactoring

Analyze this code for refactoring opportunities: [PASTE CODE]. List the top 5 improvements ranked by impact-to-effort ratio.

Identify all the code smells in this file: [PASTE CODE]. For each smell, name it, explain why it is a problem, and suggest the right type of refactoring.

This function is too long and complex: [PASTE CODE]. Where should it be split and what should each smaller function be responsible for?

Find all duplicated logic in this codebase: [PASTE CODE OR DESCRIBE FILES]. For each duplication, suggest the abstraction that would consolidate it.

Rate this code on readability, testability, and extensibility from 1-10 with specific reasoning. Then list the changes that would have the highest impact on each dimension.

Refactor this function into smaller, single-responsibility functions: [PASTE CODE]. Each function should do one thing and be independently testable.

Extract a reusable abstraction from this repeated code pattern: [PASTE CODE]. Write the extracted function or class and show how to replace each usage.

Refactor this class to follow SOLID principles: [PASTE CODE]. Identify which principles are violated and produce the refactored version.

This code mixes business logic, data access, and presentation. Separate these concerns: [PASTE CODE]. Show the new layered structure.

Replace this complex conditional logic with a cleaner pattern: [PASTE CODE]. Suggest and implement the most appropriate pattern (strategy, lookup table, polymorphism) for this case.

Modernize this code to use current [LANGUAGE] idioms and features: [PASTE CODE]. Explain what each change improves and why it is preferred today.

Convert this callback-based or promise-chained code to async/await: [PASTE CODE]. Preserve the exact behavior and add proper error handling.

Replace raw string queries with parameterized queries or an ORM in this code: [PASTE CODE]. Eliminate injection risk while maintaining the query logic.

Simplify this code using more concise [LANGUAGE] patterns without sacrificing clarity: [PASTE CODE]. Show the shorter version and explain each simplification.

Refactor this code to be unit testable by inverting dependencies: [PASTE CODE]. Show the refactored version and write one example test to demonstrate it.

What tests should I write before refactoring this code to ensure I do not break behavior: [PASTE CODE]? List the specific cases that would catch regressions.

I want to refactor this code safely: [PASTE CODE]. What is the safest order of changes and what should I verify after each step?

Show the before and after for this refactoring: [PASTE CODE + DESCRIBE DESIRED CHANGE]. Confirm the behavior is identical and highlight any behavioral differences I should watch for.

I have refactored this code: [PASTE ORIGINAL AND REFACTORED VERSION]. Are there any subtle behavioral differences I may have introduced? Check edge cases carefully.

What is the minimum-invasive change to make this code testable without a full structural refactor: [PASTE CODE]? I need to add tests before making bigger changes.