Best AI Prompts for Code Optimization with Claude Code

TL;DR

• Claude Code excels at identifying hidden performance bottlenecks that profilers miss, especially in business logic and data transformation code.
• Targeted prompts for caching strategies transform repeated computations from O(n) per call to a single lookup.
• Legacy code with implicit dependencies responds well to AI-assisted refactoring that exposes and isolates performance-critical paths.
• Building a personal prompt library of high-value optimization patterns compounds your returns over time.
• Combining AI analysis with runtime profiling gives you the fastest path from slow code to fast code.

Modern applications often contain performance bottlenecks that resist traditional debugging tools. Profilers show you where time is spent, but they rarely explain why or suggest concrete fixes. Claude Code changes this equation by reasoning about your code’s intent and identifying optimizations that go beyond microbenchmarks.

This guide gives you the specific prompts I use to optimize production code with Claude Code, from initial diagnosis to final verification.

Why Code Optimization Prompts Differ from General Code Generation

Standard code generation prompts ask AI to write new functionality. Optimization prompts require something harder: understanding what already exists, identifying what makes it slow, and proposing changes that preserve behavior while improving performance.

Claude Code handles this because it can read your full codebase context. It sees function call patterns, database queries, and data structures in relationship to each other. A general-purpose AI assistant only sees snippets. That context difference is where optimization discoveries live.

The prompts in this guide work best when you give Claude Code access to the relevant code sections. Paste the function, describe the performance problem in concrete terms, and ask for analysis before requesting changes.

Prompt for Initial Performance Analysis

Read the following function and identify the top three performance issues.
For each issue, explain:
1. Why it causes slowdown
2. What algorithm or data structure change would fix it
3. An estimate of the improvement (order of magnitude)

Do not suggest new features or changes to functionality. Focus purely on execution speed and resource usage.

This prompt works well for functions between 50 and 300 lines. For larger modules, ask Claude Code to analyze each function individually before zooming out to system-level interactions.

The key constraint in this prompt is the explicit instruction to focus on execution speed and not to introduce new features. Without this, AI tends to “improve” code by adding functionality that was never requested and often makes performance worse.

Prompt for Caching Strategy Design

Analyze this function for repeated computation patterns.
Identify:
1. Any values computed multiple times with the same inputs
2. Any expensive operations (file I/O, network calls, complex math) that could be memoized
3. Whether a cache with a TTL or a persistent cache would be appropriate

Propose a caching layer that can be added with minimal changes to the existing function signature.

Caching is the highest-leverage optimization in most business applications. A well-placed memoization cache can change a function from O(n) per call to O(1) after the first call.

Claude Code is particularly good at identifying cache opportunities that are invisible to profilers because the cost is spread across multiple call sites. When the same computation happens in different contexts, the profiler shows each call individually, but Claude Code sees the pattern.

Prompt for Algorithm Transformation

This function implements [specific algorithm type, e.g., "a nested loop search"].
Rewrite it to use [target approach, e.g., "a hash map lookup"].
Preserve the exact same inputs and outputs.
Add inline comments explaining the algorithmic change.

Specificity matters enormously here. When you name the current algorithm and the target approach, Claude Code produces a faithful transformation. When you leave it vague, it often introduces bugs by changing behavior along with the algorithm.

For nested loop comparisons, specify the exact data structures involved. “Find user by email in a list of users” gets better results than “optimize this search function.”

Prompt for Reducing Memory Allocations

This code creates many short-lived objects that trigger frequent garbage collection.
Identify the top three sources of allocation churn and suggest:
1. Object pooling or reuse strategies
2. Lazy initialization opportunities
3. Data structure changes that reduce copying

Preserve thread safety if the code is concurrent.

Memory allocation pressure is an overlooked source of slowdowns in garbage-collected languages. When GC runs frequently, it interrupts your code’s actual work. Reducing allocations often produces more measurable improvements than algorithmic changes, especially in hot code paths.

Prompt for Database Query Optimization

Review these database queries for N+1 problems, missing indexes, and inefficient joins.
For each issue found:
1. Show the problematic query pattern
2. Provide the optimized equivalent
3. Explain the expected performance difference

Assume standard relational database indexes are available.

N+1 query patterns are endemic in ORM-heavy codebases. Each lazy-loaded relationship triggers a separate query, multiplying database round trips. Claude Code can often identify these patterns from a review of repository or data access code, even without seeing the full application.

Prompt for Concurrency Improvement

This code processes items sequentially but could run in parallel.
Identify the bottleneck and suggest a concurrent approach using [preferred concurrency model, e.g., async/await, thread pools, goroutines].
Constraints:
- Maintain the same error handling behavior
- Preserve the order of results if ordering is required
- Do not introduce shared mutable state

Concurrency prompts require you to specify the constraints clearly. The order preservation requirement is particularly important because Claude Code will sometimes optimize for throughput at the expense of ordering, which breaks code that depends on sequence.

Prompt for Benchmark-Driven Optimization

Given this function and the following benchmark results [paste benchmark]:
Identify which optimizations would have the highest impact on actual runtime.
Prioritize changes by impact and suggest an implementation order.

Do not suggest changes that would require rewriting more than 20% of the function.

Benchmark-driven optimization focuses Claude Code on changes that matter. When you paste actual timing data, the model reasons about which code paths correspond to the hot spots, rather than guessing. This prevents spending effort optimizing code that runs for 2% of total time.

Prompt for Technical Debt Assessment

Perform a technical debt assessment of this module.
For each issue found, categorize it as:
- Quick win (under 1 hour to fix, significant impact)
- Planned refactor (requires dedicated sprint time)
- Architectural (needs design review)

Focus on issues that directly affect performance or maintainability.

Technical debt assessments help you prioritize. Claude Code can identify dozens of issues in a large codebase, but not all of them are worth addressing immediately. This prompt forces categorization so you can make informed decisions about where to spend refactoring time.

FAQ

How does Claude Code compare to using a profiler for finding bottlenecks?

Profilers show you where time is spent. Claude Code shows you why code is slow and how to fix it. The two tools are complementary. Use a profiler to confirm that Claude Code’s identified hot spots are actually responsible for the slowdown before investing time in optimization.

Can Claude Code optimize code without access to runtime data?

Claude Code can identify structural performance issues from code review alone, such as nested loops that could use hash lookups, repeated computations that could be cached, and N+1 query patterns. Runtime profiling data improves the accuracy of prioritization but is not required for many optimizations.

How do I prevent Claude Code from changing functionality while optimizing?

Use explicit constraints in your prompts: “Preserve the exact same inputs and outputs,” “Do not change the function signature,” and “Do not add new features.” The more specific you are about what must not change, the more reliably Claude Code respects those boundaries.

What types of optimizations does Claude Code handle best?

Claude Code handles algorithmic transformations, caching strategy design, and code pattern analysis particularly well. It is less reliable for low-level optimizations that require deep knowledge of specific hardware or memory models.

How often should I run optimization prompts on production code?

Run optimization prompts when you have identified a performance problem through profiling or user reports. Optimization without measurement often makes code faster at the cost of readability, with no actual benefit to users.

Conclusion

Claude Code’s context awareness makes it uniquely capable of identifying optimization opportunities that exist across multiple files and functions. The prompts in this guide give you a systematic toolkit for diagnosing performance problems, designing caching strategies, and transforming algorithms.

Actionable takeaways:

• Give Claude Code full context by pasting relevant code sections before asking for optimization advice.
• Use benchmark data when available to focus AI attention on actual hot spots.
• Build a personal prompt library of your highest-impact optimization patterns.
• Combine AI analysis with runtime profiling to verify that changes produce real improvements.
• Prioritize technical debt by impact using the assessment prompt before scheduling refactoring work.