Stop Asking AI to Write Code - Ask It to Debug Your Code

The problem: AI writes code, but you still debug it

You paste a stack trace into an AI chat, it suggests a fix, you apply it, and the bug remains. Or worse, the AI confidently rewrites your function and introduces three new bugs. The issue is not the AI. The issue is how you ask.

Most developers use AI as a code generator, but the real leverage is in debugging. When you ask AI to debug, you force it to reason about your specific code, not generate generic snippets. This article shows a repeatable workflow: reproduce, isolate, prompt, verify. You will walk away with commands and prompts you can use today.

Before you start: set up a minimal repro

AI debugging works best when the problem is small and self-contained. Do not paste your entire codebase. Create a minimal reproduction that isolates the failing behavior. This is the same skill you use when filing a good bug report.

For this article, we use a simple Node.js script that parses CSV data and fails on certain inputs. You can adapt the approach to any language or framework.

mkdir ai-debug-demo && cd ai-debug-demo
npm init -y
npm install csv-parse

Step 1: Write a failing script

The output is NaN, not a helpful error. This is a classic silent failure. If you asked AI to 'fix this code' without context, it might rewrite the whole parser. Instead, we will guide it to the root cause.

cat > data.csv << 'EOF'
name,amount
Alice,100
Bob,200
Charlie,unknown
David,400
EOF
node parse.js

Step 2: Reproduce the bug in isolation

Before asking AI, reduce the bug to the smallest possible input. Remove the CSV file and test the parsing logic directly. This gives the AI a focused problem and makes the fix verifiable.

node repro.js

Step 3: Craft a debugging prompt

Now ask the AI to debug, not to write. Provide the code, the input, the expected output, and the actual output. Be specific about what you have already ruled out.

Here is a prompt template that works well:

I have this Node.js script that parses a CSV and sums a column. It returns NaN for the input below.

Code:
const { parse } = require('csv-parse');
const csv = `name,amount\nAlice,100\nBob,200\nCharlie,unknown\nDavid,400`;
const records = parse(csv, { columns: true, skip_empty_lines: true });
let total = 0;
for (const record of records) {
  total += Number(record.amount);
}
console.log('Total:', total);

Input: CSV with a non-numeric value 'unknown' in the amount column.
Expected: A number, or an error message indicating the bad row.
Actual: NaN.

I have already verified the CSV is valid and the column exists. What is the root cause and the minimal fix?

• Include the exact code snippet (the smaller the better).
• State the input data (inline or as a small sample).
• State the expected output and the actual output.
• Mention what you have already checked (e.g., 'the CSV is valid, the column exists').
• Ask for the root cause, not just a fix.

Step 4: Evaluate the AI's answer

A good AI response will point out that Number('unknown') returns NaN, and NaN propagates through the sum. The fix is to validate the value or skip non-numeric rows. It should also suggest adding error handling.

Do not blindly apply the suggested fix. Read it, understand it, and test it against your repro. Here is a common AI response and how to evaluate it.

// Suggested fix from AI
let total = 0;
for (const record of records) {
  const value = Number(record.amount);
  if (isNaN(value)) {
    console.warn(`Skipping invalid amount for ${record.name}`);
    continue;
  }
  total += value;
}
console.log('Total:', total);

• Does it address the root cause? Here, yes: it checks for NaN.
• Does it handle edge cases? It skips bad rows, but maybe you want to throw an error instead.
• Does it fit your code style? It uses console.warn, which may not be appropriate for production.
• Run the repro with the fix to confirm the output is now 700.

Step 5: Verify the fix with a test

Always verify the fix with a test. Add a simple assertion to your repro so you can rerun it automatically. This turns the AI's suggestion into a regression test.

node verify.js

What I would do: a reusable debugging workflow

Here is the exact workflow I use for any bug, with or without AI. It keeps the AI focused and prevents it from wandering into unrelated rewrites.

# Save this as debug.sh and run with: bash debug.sh
# It runs the repro, prompts the AI, and then runs the test.
# Replace the AI call with your preferred tool (e.g., claude, openai).

node repro.js
# ... call AI with the prompt ...
node verify.js

• Create a minimal repro script that fails with a clear error or wrong output.
• Write a prompt that includes the code, input, expected, actual, and what you already checked.
• Ask for the root cause first, then the fix.
• Apply the fix to the repro only, not the full codebase.
• Add a test that asserts the expected behavior.
• Run the test. If it passes, integrate the fix into your real code.

Troubleshooting: when AI debugging fails

Sometimes the AI still gives a wrong answer. Here are the common reasons and how to recover.

• The repro is too complex: simplify it further. Remove dependencies, use inline data.
• The prompt lacks context: include the exact error message or output, not just 'it doesn't work'.
• The AI suggests a fix that changes behavior: ask it to explain why the original code failed, and compare the logic.
• The bug is environmental: if the repro works on your machine but fails elsewhere, check versions, environment variables, or platform-specific behavior.

FAQ

Answers to the questions that come up most often on this topic.

• Q: Should I paste my entire codebase into the AI?
• A: No. Always create a minimal repro. The AI can only reason about what you give it, and large codebases lead to generic answers.
• Q: What if the AI suggests a fix that is worse than the original?
• A: Treat the AI as a junior developer. Review the change, run your tests, and revert if needed. The repro makes this safe.
• Q: How do I debug concurrency or race conditions with AI?
• A: Reproduce the race condition with a stress test or a specific interleaving. Then ask the AI to analyze the concurrency logic, not just the code.
• Q: Can I use this workflow for code I did not write?
• A: Yes. The repro isolates the behavior, and the prompt gives the AI enough context to reason about unfamiliar code.
• Q: What about using AI to debug production incidents?
• A: Reproduce the issue in a staging environment first. Never give the AI live production data. Use the same workflow with sanitized inputs.

Next action: try it now

Create a minimal repro of your current bug, write a debugging prompt, and run it against your favorite AI. You will likely get a root cause analysis faster than staring at the code.

If you need to inspect your code or data before asking, try the JSON Diff or Diff Checker tools on code.live to compare expected and actual outputs.