The AI Debugging Prompt Pack: 20 Prompts to Find Bugs

I'm going to describe a bug I'm seeing. I want you to do two things:
1. Restate the bug back to me in precise technical language.
2. List the 3 most likely root cause categories based on my description.

Here's what I'm observing: [describe the symptom, what you expected vs. what happened, and when it started]

Don't suggest fixes yet. I want to understand the problem better before jumping to solutions.

Here's an error message I'm seeing:

[paste full error message and stack trace]

Explain this error in plain English. Tell me:
1. What went wrong (in one sentence a non-expert could follow)
2. What the most likely cause is
3. What layer of the stack this is happening in (database, API, frontend, auth, etc.)
4. What I should look at first

My tech stack is: [list your stack]

Something broke. I need to figure out what changed that caused it.

Here's what I know:
- It was working as of: [date/deployment/commit]
- It stopped working when: [date/deployment/commit, or "I don't know"]
- What changed between those two points (that I know of): [list changes, or "unknown"]
- The symptom: [describe what's broken]

What questions should I be asking to isolate what change caused this? And based on what I've told you, what's your best hypothesis about the source?

I'm trying to reproduce a bug reliably. Here are the steps I currently use to reproduce it:

[list your current reproduction steps]

The bug: [describe]
How consistently it reproduces: [always / sometimes / rarely]
Conditions where it seems worse or better: [describe, or "unknown"]

Help me:
1. Tighten these reproduction steps to the minimum needed
2. Identify variables I should control or isolate
3. Suggest conditions that might make this reproduce more consistently

I have a bug and I'm not sure which layer it's in. Here's what I know:

Symptom: [describe]
Stack: [frontend / backend / database / auth / third-party API / other]
What I've already ruled out: [list]
What I haven't checked yet: [list, or "I don't know where to start"]

Give me a systematic checklist, ordered by likelihood, of where to look first. For each item, tell me how to confirm or rule it out quickly.

I suspect this code is causing a bug. Review it and tell me:
1. Any logic errors you can see
2. Edge cases this doesn't handle
3. Assumptions this code makes that might not hold
4. Any conditions under which this would fail silently

The bug I'm seeing: [describe symptom]
Expected behavior: [describe]

Code:
[paste code block]

Here are logs from around the time the bug occurred. I want you to:
1. Identify the sequence of events leading up to the failure
2. Highlight any anomalies even if they don't look like errors
3. Tell me what's missing that should be there (missing log entries can be as telling as errors)
4. Give me your best hypothesis about what caused the failure

Logs:
[paste logs]

Context: [describe what the system was doing, what the expected flow is]

I'm debugging an issue with an API call. Here's everything I have:

Request:
[paste request, including headers if relevant, with sensitive keys redacted]

Response:
[paste response or error]

Expected behavior: [describe]
Actual behavior: [describe]

Tell me:
1. Is the request malformed in any way?
2. Does the response indicate a server-side problem or a client-side problem?
3. What should I check next?
4. Are there common gotchas with this type of API call I might be missing?

I have a bug that seems to depend on application state. It only happens under certain conditions, not all the time.

Here's what I know:
- When it happens: [describe triggering conditions]
- When it doesn't happen: [describe conditions where it works fine]
- Relevant state at the time of failure: [paste or describe state/variables]
- What the code expects the state to be: [describe]

Walk me through how state could cause this discrepancy. What state mutations should I trace? What's the most likely state-related cause?

I have an intermittent bug that I suspect might be a race condition or timing issue.

Symptoms: [describe, including how often it happens]
Relevant code (async operations, event handlers, concurrent processes): [paste]
Environment: [describe: serverless, multi-threaded, single-threaded, browser, etc.]

Help me:
1. Evaluate whether this is likely a race condition
2. Identify the specific points where timing could cause this
3. Suggest how to test the hypothesis
4. If it is a race condition, what are the standard approaches to resolve it?

I think I'm dealing with a data bug. The code looks right, but the output is wrong.

Here's a sample of the input data: [paste sample]
Here's what the code produces: [paste output]
Here's what it should produce: [describe]
The transformation logic: [paste code or describe]

Help me figure out:
1. Is the input data well-formed or does it have issues?
2. Are there specific data values or shapes that would cause this code to fail?
3. Where should I add validation or normalization?

I found a bug. I want to understand the root cause before I fix it, because I don't want to create a new bug or fix the same thing in six places.

The bug: [describe]
The immediate cause I found: [describe what you found]
The fix I'm considering: [describe]

Run a five-whys analysis with me. Start from the immediate cause and help me trace it back to the root. For each layer, tell me what question to ask next.

I have a fix for a bug. Before I apply it, I want to pressure-test it.

The bug: [describe]
My proposed fix: [paste code or describe approach]

Tell me:
1. Does this fix the root cause or just the symptom?
2. What edge cases could this fix break?
3. Are there other places in the codebase where the same bug might exist?
4. What's the safest way to apply this change?
5. What should my test cases cover to validate this fix?

I'm about to make this change to fix a bug:

[paste the change you're making]

Context on the system: [describe what this code does, what depends on it]

Before I apply it, help me identify:
1. What else could this change affect?
2. What assumptions does this change make that other parts of the system might violate?
3. What should I test beyond just the bug I fixed?
4. Is there a safer, more targeted way to make this change?

I have a fix that works, but I think it's more complex than it needs to be.

The bug: [describe]
My current fix: [paste code]

Help me find the minimal change that resolves this bug correctly. I want:
1. The smallest change with the fewest side effects
2. No loss of correctness
3. A brief explanation of why the simpler version is sufficient

I just fixed a bug. I want to write a regression test so it never ships again undetected.

The bug: [describe]
The fix: [paste]
My testing framework: [describe]

Write a regression test that:
1. Would have caught this bug before the fix
2. Confirms the fix is working correctly
3. Covers the edge cases around this bug
4. Is isolated enough to run fast

I just resolved a significant bug. Help me write a short, useful post-mortem.

The bug: [describe]
How it was found: [describe]
Time to resolve: [duration]
Impact: [describe: users affected, features down, data issues, etc.]
Root cause: [what you found]
The fix: [describe]

Structure this as:
1. What happened (2-3 sentences)
2. Why it happened (root cause, not just the immediate cause)
3. How we found it
4. What we fixed
5. What we're changing to prevent recurrence

Keep it under one page. Make it useful for someone who wasn't involved.

I want to audit this code for error handling gaps.

[paste code]

Tell me:
1. Which errors or exceptions could occur here that aren't currently caught?
2. Where is failure silent when it should be loud?
3. Where is failure loud when a graceful fallback would be better?
4. What logging should be added to make future debugging faster?
5. What's the most dangerous failure mode here?

I want to harden this code against bad inputs.

[paste function or module]

It currently receives: [describe what inputs it gets and from where]
It currently validates: [describe any existing validation]

Help me:
1. List every input assumption this code makes
2. Identify which assumptions could be violated in production
3. Suggest validation logic for the riskiest inputs
4. Flag any inputs where failing loudly is better than a silent default

I just fixed a bug and I want to find every other place the same pattern is hiding.

The bug I fixed: [describe the symptom]
The root cause: [describe the underlying pattern, not the specific line]
The fix: [paste]
My codebase: [describe stack, rough size, and how it's organized]

Help me:
1. Describe the abstract pattern behind this bug, independent of the file it happened in
2. Give me specific search terms, grep patterns, or structural signatures to find other instances
3. List the places in a codebase like mine where this pattern usually hides
4. Rank what you find by blast radius, so I fix the dangerous ones first
5. Suggest a lint rule, type change, or convention that would make this whole class of bug impossible going forward