Code Optimization and Refactoring Prompts

Code optimization and refactoring are essential skills for developers who want to improve code quality without changing what the program does. Clear prompts help AI understand exactly what you need when cleaning up messy code or making it run faster. SeriesWire provides a prompt generator and a prompt library to help developers work more efficiently with AI coding assistants.

These prompts are templates. Replace the bracketed placeholders with your own details such as programming language, performance targets, specific code sections, or constraints. Each prompt gives the AI enough structure to provide useful suggestions without limiting your specific needs.

Performance Optimization Prompts

Performance issues slow down applications and frustrate users. These prompts help you identify bottlenecks and get specific optimization recommendations.

Analyze the following code for performance bottlenecks and suggest specific code optimization improvements: [paste your code]. Focus on [time complexity/memory usage/database queries] and provide refactored versions with explanations.

Review this [language] function for optimization opportunities: [paste function]. The function currently takes [current execution time] and needs to handle [data volume]. Suggest algorithm improvements and estimate performance gains.

Identify inefficient patterns in this codebase: [paste code]. Look for [redundant loops/excessive API calls/memory leaks/unnecessary calculations]. Provide refactoring suggestions with code examples.

Optimize this [database query/API call/file processing operation]: [paste code]. Current performance is [metric]. Target performance should be [goal]. Consider [specific constraints like backwards compatibility or memory limits].

Code Structure Refactoring Prompts

Clean structure makes code easier to maintain and extend. These prompts help reorganize code without breaking functionality.

Refactor this [class/module/function] to follow [SOLID principles/DRY principle/separation of concerns]: [paste code]. Explain each structural change and why it improves maintainability.

Break down this large function into smaller, focused functions: [paste function]. Each new function should [single responsibility]. Maintain [error handling/logging/validation] from the original code.

Reorganize this code to improve modularity: [paste code]. Suggest how to split it into [services/utilities/helpers] and show the new file structure with import statements.

Refactor this procedural code into object-oriented design: [paste code]. Create appropriate [classes/interfaces/inheritance structure] while preserving [specific behavior or edge cases].

Code Readability Improvement Prompts

Readable code saves time for everyone who touches it later. These prompts focus on clarity and maintainability.

Improve variable and function names in this code: [paste code]. Replace unclear names with descriptive alternatives that follow [naming convention]. Explain the reasoning behind each change.

Add meaningful comments and documentation to this code: [paste code]. Focus on explaining [why decisions were made/complex logic/edge cases] rather than what the code does.

Simplify this complex conditional logic: [paste nested if statements or switch case]. Refactor into [guard clauses/lookup tables/polymorphism] to improve readability.

Remove code duplication in these [functions/classes/modules]: [paste duplicated code sections]. Extract common logic into [shared utilities/base classes/composition]. Show before and after versions.

Memory and Resource Management Prompts

Efficient resource use prevents crashes and improves scalability. These prompts target memory leaks and resource waste.

Review this code for memory leaks and resource management issues: [paste code]. Check for [unclosed connections/circular references/event listener cleanup]. Provide corrected code with proper cleanup.

Optimize memory usage in this [data structure/algorithm/cache implementation]: [paste code]. Current memory footprint is [size]. Suggest approaches to reduce it to [target] without sacrificing [performance requirement].

Refactor this code to use memory pooling or object reuse: [paste code]. The application creates [number] instances per [time period]. Show how to implement efficient reuse patterns.

Analyze garbage collection impact in this code: [paste code in garbage collected language]. Suggest refactoring to reduce [allocation pressure/GC pauses]. Focus on [hot path/critical section].

Database and Query Optimization Prompts

Slow queries often cause the worst performance problems. These prompts help optimize database interactions.

Optimize this SQL query for better performance: [paste query]. Current execution time is [duration] on [table size]. Suggest [index additions/query restructuring/join optimization] and explain the impact.

Refactor this N+1 query problem: [paste code with database calls]. Show how to use [eager loading/batch queries/joins] to reduce database round trips from [current] to [target].

Review this ORM code for performance issues: [paste ORM queries]. Identify [inefficient lazy loading/missing indexes/unnecessary fetches]. Provide optimized versions with performance comparison.

Suggest caching strategy for these database queries: [paste queries]. Queries run [frequency] with [data change rate]. Recommend [cache duration/invalidation strategy/cache key structure].

Algorithm and Logic Refactoring Prompts

Better algorithms can transform slow code into fast code. Understanding program optimization principles helps you identify where algorithmic improvements make the most difference.

Analyze time complexity of this algorithm: [paste algorithm]. Current complexity is [O notation]. Suggest refactoring to achieve [target complexity] and explain the trade-offs.

Replace this brute force approach with an efficient algorithm: [paste code]. The code processes [data size] and needs to [specific task]. Suggest appropriate [data structure/algorithm] and show implementation.

Refactor this recursive function to [iterative approach/tail recursion/memoization]: [paste function]. Explain when the refactored version performs better and any limitations.

Optimize this search or sort operation: [paste code]. Current approach uses [algorithm]. Data characteristics are [mostly sorted/random/small range]. Suggest better algorithm choice with code example.

Error Handling and Validation Refactoring Prompts

Robust error handling prevents bugs and improves debugging. These prompts improve reliability.

Add comprehensive error handling to this code: [paste code]. Cover [input validation/exception cases/edge conditions]. Use [error handling pattern for your language/framework].

Refactor this try-catch block to be more specific: [paste error handling code]. Replace generic exceptions with [specific exception types]. Add appropriate [logging/recovery/user feedback].

Improve input validation in this function: [paste function]. Validate [data types/ranges/format/business rules]. Return clear error messages that explain [what failed and how to fix it].

Convert defensive programming checks into [assertions/guard clauses/validation layer]: [paste code with scattered checks]. Centralize validation and improve [testability/maintainability].

API and Integration Code Refactoring Prompts

External integrations need resilience and clarity. These prompts help clean up integration code.

Refactor this API client code for better error handling: [paste API code]. Add [retry logic/timeout handling/circuit breaker pattern]. Handle [rate limits/network failures/API changes].

Optimize these sequential API calls to run in parallel: [paste code]. Calls are currently [blocking/sequential]. Show how to use [promises/async-await/worker threads] to improve performance.

Extract API integration logic into a separate service layer: [paste mixed business and API code]. Separate [API calls/response parsing/error handling] from [business logic]. Show new structure.

Add response caching to this API client: [paste API code]. API calls happen [frequency] with [staleness tolerance]. Implement [cache strategy] with appropriate [TTL/invalidation].

Code Testing and Testability Prompts

Testable code is refactorable code. These prompts improve code design for better testing.

Refactor this code to make it testable: [paste code with hard dependencies]. Extract [dependencies/side effects] to allow [mocking/stubbing]. Show how to inject dependencies.

Break down this complex function for unit testing: [paste function]. Split into [pure functions/testable units]. Show example test cases for each unit.

Remove test-hostile patterns from this code: [paste code]. Replace [static methods/global state/hidden dependencies] with [testable alternatives]. Explain the testing benefits.

Add test coverage for edge cases in this code: [paste code and existing tests]. Identify missing test scenarios for [boundary conditions/error cases/null handling]. Write additional test cases.

Legacy Code Modernization Prompts

Old code needs updates to stay maintainable. These prompts help bring legacy code to modern standards.

Modernize this legacy [language version] code to current standards: [paste old code]. Update [syntax/deprecated functions/outdated patterns] to [current version] best practices.

Refactor this callback-based code to use [promises/async-await]: [paste callback code]. Improve readability and error handling. Show the migration path for [complex callback chains].

Convert this procedural legacy code to use modern [framework/library]: [paste code]. Maintain [existing functionality/data structures] while adopting [framework patterns/conventions].

Remove deprecated dependencies from this code: [paste code using old libraries]. Replace [deprecated library] with [modern alternative]. Show equivalent functionality and migration steps.

Security and Best Practice Refactoring Prompts

Secure code protects users and data. These prompts identify security improvements.

Review this code for security vulnerabilities: [paste code]. Check for [SQL injection/XSS/CSRF/authentication bypass]. Provide secure refactored versions following [OWASP guidelines].

Refactor this code to follow [language] security best practices: [paste code]. Address [input sanitization/credential handling/encryption/access control] issues.

Replace insecure patterns in this code: [paste code]. Fix [hardcoded secrets/weak cryptography/unsafe deserialization]. Show secure alternatives with explanation.

Add security headers and validation to this API endpoint: [paste endpoint code]. Implement [authentication/authorization/rate limiting/input validation]. Follow [REST/GraphQL] security standards.

Practical Application of Optimization and Refactoring Prompts

These prompts work best when you provide specific context about your codebase. AI tools give better suggestions when they understand your performance goals, technical constraints, and coding standards.

Common mistakes include asking for optimization without profiling first. Always measure performance before and after changes. Another pitfall is refactoring too much at once. Small focused changes are easier to test and debug. When using these prompts, start with the biggest pain points in your code. Performance bottlenecks that affect users matter more than minor inefficiencies in rarely used code.

Some developers forget to specify their technology stack and constraints. The same optimization approach works differently in Python versus C++ or in a serverless environment versus a traditional server. Include these details in your prompts.

Code refactoring and optimization often require trade-offs between readability, performance, and maintainability. Make these priorities clear when crafting your prompts. The AI can then suggest solutions that match your specific situation rather than generic advice.

How to Use These Prompts

These prompts are templates that need customization. Replace every bracketed placeholder with information specific to your code. For example, replace [paste your code] with actual code snippets, [language] with Python or JavaScript, and [performance targets] with specific metrics.

Start by copying a prompt that matches your optimization goal. Fill in the bracketed sections with relevant details about your codebase, constraints, and objectives. The more specific you are, the better the AI response will be.

Test the AI suggestions in a development environment before applying them to production code. Not every suggestion will fit your exact situation. You might need to adapt the output or combine ideas from multiple prompts. Refining prompts based on results helps you learn what works for your codebase.

When working on code optimization, run performance benchmarks before and after changes. This proves whether the refactoring actually improved things. For complex refactoring projects, use these prompts iteratively. Start with high-level structure, then drill down into specific functions or modules.