Debugging is where AI assistants can save the most time, if you describe the problem well. A vague "my code does not work" gets a vague answer. A precise report with the error, the code and what you have tried often leads straight to the cause. These prompt patterns will help you debug faster, and they teach good habits that also help when asking colleagues or forums for help.
Pattern 1: the complete bug report
Give the assistant the same information a human would need.
Language/framework: Python 3.12, Django 5.0
Goal: Show only published posts on the blog list page.
Problem: The list page shows draft posts too.
Expected: only posts where status="published".
Actual: all posts are displayed.
Relevant code:
<paste the view and the model snippet>
What I tried: filtering in the template with {% if post.status == "published" %}.This structure (environment, goal, expected, actual, code, attempts) removes guesswork.
Pattern 2: paste the full error
Include the whole traceback, not just the last line. The earlier lines show which of your files triggered the error.
I get this error. Explain what it means in simple terms, identify which line of MY code is the cause,
and suggest a fix.
<paste the full traceback>Remove any secrets such as passwords, tokens and private URLs first.
Pattern 3: the minimal reproducible example
Shrink the problem to the smallest code that still fails. Ask the assistant to help:
Here is my 120-line script that crashes. Help me reduce it to a minimal example that still shows the bug, and remove everything unrelated.
Creating a minimal example often reveals the bug before you even ask the question.
Pattern 4: ask for hypotheses, not just a fix
List the three most likely causes of this behaviour, ranked by probability. For each, tell me one quick check I can run to confirm or rule it out.
This keeps you in control and teaches you to debug systematically.
Pattern 5: trace the code step by step
When a function returns the wrong value, ask for a walk-through with sample input.
Walk through this function line by line with the input
[3, 0, 5]and show the value of each variable after every step. Point out where the result differs from what I expect.
You can also add print statements yourself and share the output.
Pattern 6: compare expected and actual output
Show both clearly:
Input: " Hello World "
Expected: "hello world"
Actual: "hello world"Concrete examples are more useful than descriptions.
Pattern 7: explain it back
Explain in plain English what this code does, then list anything that looks suspicious.
If the assistant's explanation differs from what you intended, that gap is often where the bug lives (rubber-duck debugging with a very patient duck).
Pattern 8: request a minimal, safe fix
Ask for the smallest change and an explanation:
Suggest the smallest change that fixes the bug without altering other behaviour. Show a diff and explain why it works. Do not refactor unrelated code.
This avoids huge rewrites that introduce new bugs.
Pattern 9: ask for a test that catches it
Write a failing test that reproduces this bug, then show the fix that makes it pass.
Having a test prevents the problem from returning.
Pattern 10: performance and logic problems
For slow code, share timing results and data sizes: "This function takes 12 seconds for 50,000 rows. Here is a profile output. Where is the time spent and how can I improve it?" For logic bugs, share the rules in words as well as code.
A worked example
Suppose this function should return the average of positive numbers, but it crashes on an empty list.
def average_positive(numbers):
positives = [n for n in numbers if n > 0]
return sum(positives) / len(positives)
print(average_positive([-1, -2]))The error is ZeroDivisionError: division by zero. A good prompt includes the code, the traceback and the case that triggers it. The reply should identify that positives is empty and suggest handling it explicitly:
def average_positive(numbers):
positives = [n for n in numbers if n > 0]
if not positives:
return None # or raise ValueError, depending on your design
return sum(positives) / len(positives)Notice that there is a design decision here (return None or raise an error). Good assistants point this out, and you should decide.
What not to do
- Do not paste a whole project and say "fix it".
- Do not accept a fix you do not understand.
- Do not share credentials, personal data or proprietary code with tools your organisation has not approved.
- Do not assume the assistant ran your code. Unless it is connected to an execution tool, it is reasoning, not testing.
Verify the fix
- Run the original failing case.
- Run your tests.
- Try related edge cases.
- Read the final diff to make sure nothing else changed.
- Write down the cause so you recognise it next time.
Frequently Asked Questions
Why does the assistant sometimes give a wrong fix?
It may lack key context, assume a different library version, or guess. Providing exact versions, code and error messages improves accuracy.
Should I paste my whole file?
Paste the relevant functions and the error. If the issue depends on structure, include a short outline of the other parts.
Can AI find bugs without an error message?
Often yes, by reviewing code or tracing logic, but it helps to describe the expected and actual behaviour.
Will relying on AI hurt my debugging skills?
It can if you only copy fixes. Use it to generate hypotheses and explanations, and keep practising reading errors yourself.
Conclusion
The best debugging prompts include the environment, the goal, the exact error, the relevant code and what you already tried. Ask for hypotheses, minimal fixes and tests, and verify everything. Done this way, an assistant becomes a fast and patient debugging partner.