15 Prompts for Debugging and Squashing Bugs in Code

Debugging is the art of finding a needle in a haystack while blindfolded. Every developer has faced the sting of a bug that only appears in production, or an error message that reads like ancient runes. With the rise of AI coding assistants, we now have a powerful ally: prompt engineering. The right prompt can turn a vague "it doesn't work" into a precise diagnosis and a clean fix. This article collects 15 battle-tested prompts that you can copy-paste into ChatGPT, Claude, or any LLM-powered debugger. Each prompt includes a concrete example and a code snippet to try immediately. No fluff, just practical value.

Debugging is a core skill, but AI can shorten the feedback loop significantly. As the classic book The Pragmatic Programmer reminds us, debugging is "relentless and ruthless"—you must never theorize without evidence. LLMs help you generate hypotheses faster and explore more angles. However, they are not magic: the quality of the output depends directly on the quality of the input. This is where prompt design matters. In the following sections, you'll learn how to structure prompts, what context to include, and how to verify AI suggestions.

How to Write Effective Debugging Prompts

A good debugging prompt is like a well-formed bug report. It contains just enough context for the model to narrow down the problem. Based on my experience, the most effective prompts include the following components:

Now let's dive into the 15 prompts. Try them on your own codebase; each one targets a common debugging scenario.

The 15 Prompts

1. Explain This Error Message

Prompt template:

I got this error message in [language/framework]:
[PASTE ERROR]

Explain what it means in simple terms, what are the possible causes, and how to fix it.

Why it works: Many errors are cryptic (e.g., TypeError: Cannot read property 'map' of undefined). The model can decode the message and point you to the root cause.

Example:

// JavaScript/React
const data = await fetch(url);
data.map(item => console.log(item)); // TypeError: Cannot read property 'map' of undefined

Feed the prompt with the error and the code. The model will explain that data is not an array but a Response object, and that you need await response.json().

2. Find the Bug in This Code

Prompt template:

This code is supposed to [describe expected behavior] but it does [actual behavior].
Please find the bug and suggest a fix. Here is the code:
[PASTE CODE]

Why it works: By framing the expected vs. actual, you force the model to reason about the logic, not just syntax.

Example:

# Python
def calculate_total(prices):
    total = 0
    for i in range(len(prices)):
        total += prices[i]
    return total

print(calculate_total([1, 2, 3]))  # outputs 6, correct
print(calculate_total([]))          # outputs 0, correct

But what if you intended to ignore taxes? Give the context: "This function should return the total with tax applied, but it returns the sum without tax." The model will spot the missing * 1.2 or similar.

3. Trace the Execution Flow

Prompt template:

Trace the execution of this code step by step, showing me the state of each variable at each line. Focus on where [variable] changes.
[PASTE CODE]

Why it works: When you can't see the wood for the trees, a line-by-line trace makes the state visible.

Example:

function merge(a, b) {
    const result = {};
    for (let key in a) result[key] = a[key];
    for (let key in b) {
        if (b[key] !== undefined) result[key] = b[key];
    }
    return result;
}

Ask the model to trace merge({x:1}, {x:undefined}). It will walk through the loops and show how undefined values are skipped.

4. Write a Unit Test to Reproduce the Bug

Prompt template:

Write a [pytest/JUnit/Jest] unit test that reproduces this bug. The test should fail with the current code and pass after the fix.
[PASTE CODE]
[PASTE ERROR OR BEHAVIOR]

Why it works: A test gives you an executable specification. It also helps the model verify its own suggested fix.

Example:

# Python (pytest)
# current function
def divide(a, b):
    return a // b  # integer division, not float

# The bug: divide(5, 2) should return 2.5, but returns 2

Ask for a test. The model will produce:

def test_divide():
    assert divide(5, 2) == 2.5

Now you have a failing test, then you can fix the function to use / instead of //.

5. Suggest Logging Statements

Prompt template:

I have a function that sometimes does the wrong thing. Add logging statements to help me understand what it does. Use [logging library].
[PASTE CODE]

Why it works: Strategic logging is often faster than using a debugger. The model can place console.log or logger.info at key decision points.

Example:

function processOrder(order) {
    let discount = 0;
    if (order.customer.isVIP) {
        discount = 0.1 * order.total;
    }
    return order.total - discount;
}

Ask for logging and the model will suggest:

function processOrder(order) {
    console.log('processOrder called with:', order);
    let discount = 0;
    if (order.customer.isVIP) {
        discount = 0.1 * order.total;
        console.log('VIP discount applied:', discount);
    }
    return order.total - discount;
}

Then you can inspect the logs and see that order.customer.isVIP is undefined, causing no discount.

6. Compare Expected vs. Actual Output

Prompt template:

Here is an input and the output my program produces. I expected [expected], but got [actual].
What could cause this difference? My code:
[PASTE CODE]
Input: [INPUT]

Why it works: The model can reverse-engineer the logic and see where the discrepancy arises.

Example:

Input: "2023-12-31"
Expected: "2024-01-01"
Actual: "2024-12-31"

The model may spot that you are incorrectly parsing the month and day by not using strptime correctly.

7. Refactor This Code for Debuggability

Prompt template:

This code works but is hard to debug because [reason]. Refactor it to make it more readable and maintainable, using smaller functions and clearer variable names. Then explain the steps.
[PASTE CODE]

Why it works: Complex code hides bugs. Simplifying it often surfaces the issue.

Example:

// Before
let a = 1, b = 2, c = 3;
let res = (a*b + c) * (a - c) / (b + c);

Ask the model to refactor into named pieces like calculateNumerator() and calculateDenominator(). The bug becomes evident when you see division by zero because b + c could be 5, which is fine, but if it's 0, you get an exception.

8. Check for Null and Undefined Errors

Prompt template:

I'm getting a 'null' or 'undefined' error. Check my code for possible uninitialized values or missing properties. Here is the stack trace:
[PASTE STACK TRACE]
And here is the relevant code:
[PASTE CODE]

Why it works: Null reference exceptions are among the most common bugs. The model can trace data flow and identify where a variable may not be set.

Example:

const user = getUser();
console.log(user.name); // TypeError: Cannot read property 'name' of null

Ask the model to check getUser() and it will suggest you verify that the API actually returns a user object, or add a guard clause.

9. Review This Stack Trace

Prompt template:

I have this stack trace. Explain what the program was doing when it crashed, and identify the root cause.
[PASTE STACK TRACE]

Why it works: Stack traces are dense; an LLM can summarize the chain of calls and point to the deepest frame where the actual error originates.

Example:

Exception in thread "main" java.lang.NullPointerException
    at com.example.OrderService.calculate(OrderService.java:42)
    at com.example.OrderController.checkout(OrderController.java:18)

The model will explain that OrderService.calculate line 42 is the root, and likely order.getTotal() returns null.

10. Generate a Minimal Reproduction Case

Prompt template:

I have a large codebase. Help me create a minimal reproduction case for this bug. The bug occurs when [describe]. Reduce the code to the smallest possible snippet that still triggers the error.
[PASTE RELEVANT CODE]

Why it works: A minimal repro makes it easier to test and isolate. The model can strip away unrelated dependencies.

Example: You have a large React app and a state update bug. The model can extract a small component with just the useState and a button that causes the issue.

11. Explain This Concept in Simple Terms

Prompt template:

I don't fully understand [concept] in [language/framework]. Explain it like I'm new to this, with a simple example. Then relate it to my code:
[PASTE CODE]

Why it works: Sometimes the bug is in your understanding, not your code. Clarifying a rough concept can instantly reveal the fix.

Example: If you're confused about this in JavaScript, the model can explain it with examples and then point out that your arrow function preserves this differently, which might be causing the issue.

12. Identify Race Conditions

Prompt template:

I have a multi-threaded or async program. I suspect a race condition. Analyze this code for shared mutable state and suggest synchronization.
[PASTE CODE]

Why it works: Concurrency bugs are notoriously hard to reproduce. The model can reason about interleavings and point out where two processes could contradict each other.

Example:

import threading
counter = 0

def increment():
    global counter
    for _ in range(1000):
        counter += 1

threads = [threading.Thread(target=increment) for _ in range(2)]
for t in threads: t.start()
for t in threads: t.join()
print(counter)  # often less than 2000

The model will identify the race condition and suggest using a lock or queue.

13. Find the Performance Bottleneck

Prompt template:

My program is slow. Based on this profiling output and these code hotspots, identify the bottleneck and suggest optimizations. Also suggest how to add more profiling if needed.
[PASTE PROFILER OUTPUT]
[PASTE CODE]

Why it works: Performance issues are bugs too. The model can interpret profiler data and propose algorithmic changes.

Example: If the profiler shows a nested loop being called millions of times, the model can suggest using a hash map or reducing time complexity.

14. Write a Script to Test Edge Cases

Prompt template:

I need to test this function thoroughly. Generate a list of edge cases (empty input, duplicates, extreme values, etc.) and write a script that runs them.
[PASTE CODE]

Why it works: Many bugs only appear at boundaries. An exhaustive test script can expose them.

Example:

def is_palindrome(s):
    s = s.replace(' ', '').lower()
    return s == s[::-1]

Edge cases: empty string, single character, punctuation, non-ASCII characters, very long string.

15. Translate This Legacy Code for Debugging

Prompt template:

I have legacy code in [old language]. Translate it to [modern language] so I can run it in a debugger. Preserve the logic exactly.
[PASTE CODE]

Why it works: Sometimes you can't run the old code in a modern environment, so translating it into something you can execute and instrument helps you understand its behavior.

Example: Convert a COBOL snippet to Python for testing. The model can maintain semantics while giving you a runnable version.

Comparison of Prompt Types

Best Practices for AI-Assisted Debugging

• Always provide the exact error message and stack trace. LLMs are sensitive to spelling and symbol differences.
• Include the smallest code snippet that reproduces the issue. If the bug is in a large file, narrow it down manually first.
• Mention what you've already tried. This prevents the model from suggesting the same dead end.
• Ask for an explanation, not just the fix. Understanding why the bug exists will help you avoid similar issues.
• Verify the AI's suggestion. Run tests or at least think through edge cases. AI can be confidently wrong.
• Use a version-controlled codebase. This lets you experiment with AI suggested fixes safely.

Common Pitfalls to Avoid

• Overly broad prompts: "Check my code for bugs" usually yields generic advice. Be specific.
• Forgetting to sanitize sensitive data: Never paste API keys or private data into a public LLM.
• Blindly accepting fixes: Always compare the AI's fix with your codebase conventions.
• Ignoring the root cause: The AI might give you a band-aid. Ask for the deeper reason and a preventive measure.

Conclusion

Debugging is a skill that improves with practice, and AI prompts are a powerful accelerant. The 15 prompts above cover the most common debugging scenarios: understanding errors, isolating logic bugs, tracing state, writing tests, and even refactoring for clarity. Use them as a toolkit, adapt them to your own style, and always keep your own critical thinking in the loop.

Start by trying one prompt today. Pick a bug that's been annoying you, paste it into your favorite AI assistant with one of these templates, and see how it changes your debugging flow. The more you practice, the better you'll get at both debugging and prompting. Remember: every expert coder was once a bug-squashing beginner—but now you have an AI co-pilot to help you squash them faster.