AI Prompts for ChatGPT for Refactoring

Analyze this code for refactoring opportunities: [PASTE CODE]. Identify the top 5 most impactful improvements ranked by value vs. effort.

What are the code smells in this file: [PASTE CODE]? List each smell, explain why it is a problem, and suggest what type of refactoring would address it.

This function is too long and hard to follow: [PASTE CODE]. Where should it be broken up and what should each smaller function be responsible for?

Identify all the places in this codebase where logic is duplicated: [PASTE CODE OR DESCRIBE FILES]. For each duplication, suggest how it should be consolidated.

Rate this code on readability, maintainability, and extensibility: [PASTE CODE]. Give specific reasoning for each rating and prioritize what to fix first.

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

Extract a reusable utility/helper from this code that is used in multiple places: [PASTE CODE]. Write the extracted function and show how to replace the inline duplications.

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

This code mixes concerns (UI, business logic, data access). Refactor it to separate these layers clearly: [PASTE CODE]. Show the new structure.

I have multiple if/else chains doing similar things in this code: [PASTE CODE]. Replace them with a more maintainable pattern (strategy pattern, lookup table, etc).

Modernize this [JAVASCRIPT/PYTHON/JAVA/ETC] code to use current best practices and language features: [PASTE CODE]. Explain what each change improves.

Refactor this callback-based code to use async/await: [PASTE CODE]. Preserve the behavior exactly and add proper error handling.

Replace these raw SQL strings with parameterized queries or an ORM: [PASTE CODE]. Maintain the query logic while eliminating injection risk.

Simplify this code using more idiomatic [LANGUAGE] patterns: [PASTE CODE]. Show the shorter, cleaner version and explain what each simplification does.

This code was written without considering testability. Refactor it to be unit testable by injecting dependencies: [PASTE CODE]. Show the refactored version and an example test.

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

I want to refactor this code but I am afraid of breaking it: [PASTE CODE]. What is the safest order of changes and what should I verify at each step?

Write before and after versions of this refactoring: [PASTE CODE + DESCRIBE DESIRED CHANGE]. Show the original, the refactored version, and confirm the behavior is identical.

I refactored this code: [PASTE ORIGINAL AND NEW VERSION]. Are there any behavioral differences I may have introduced? Check for subtle logic changes.

What is the minimum set of changes needed to make this code testable without a full refactor: [PASTE CODE]? I want to add tests first before any structural changes.