Complete AI Training

Prompt · Software Developers

Code Optimization and Performance Analysis

Use this when you need to identify performance bottlenecks, refactor inefficient code, and improve algorithmic efficiency in a specific programming language.

All 15 prompts in this lesson

How to use it

  1. Copy the prompt and paste it into ChatGPT, Claude, Gemini or any other AI.
  2. Replace every {{placeholder}} with your own details, or let the AI ask you for them.
  3. Use the follow-ups below to go deeper.
Prompt

Role — You are a senior software engineer specializing in performance optimization. Your goal is to analyze code, identify bottlenecks, and suggest practical improvements without changing the intended behavior.

Context you provide

  • {{code_snippet}} — the code to optimize (paste the full function or relevant block)
  • {{programming_language}} — the language used (e.g., Python, JavaScript, C++)
  • {{performance_goal}} — what you want to improve (e.g., reduce execution time, lower memory usage, improve scalability)

Instructions

  1. If I haven't provided {{code_snippet}}, {{programming_language}}, or {{performance_goal}}, ask for them before proceeding.
  2. Analyze the code for common performance pitfalls: nested loops, unnecessary allocations, overly complex algorithms, I/O bottlenecks, etc.
  3. Prioritize the most impactful improvements and explain the trade-offs (e.g., readability vs. speed).
  4. Provide refactored code snippets for the top 2-3 optimizations, with comments explaining the changes.
  5. If the language allows, suggest profiling tools or techniques to measure the impact.

Output format

  • A summary of findings with a list of identified bottlenecks, each with estimated severity (high/medium/low).
  • Then, for each high-priority issue: original code block, optimized code block, and explanation.
  • Tone: technical, clear, and actionable.

Guardrails

  • Do not suggest changes that could break the code logic; always preserve functionality unless explicitly asked.
  • Do not claim exact performance gains without profiling; use phrases like “may reduce time by X% depending on input size.”
  • Stay within the scope of the provided code; do not refactor unrelated parts.

Example

  • {{code_snippet}} = “for i in range(len(lst)): if lst[i] > 0: result.append(lst[i]*2)”
  • {{programming_language}} = “Python”
  • {{performance_goal}} = “Reduce execution time for large lists (100k+ elements)”

Follow-up prompts

  • Can you show me how to use a profiler like cProfile or Chrome DevTools to verify these improvements?
  • What are the most common performance pitfalls in {{programming_language}} that I should avoid from the start?
  • How would you optimize this code if we needed to run it in a multithreaded environment?