AI Coding

How to Debug AI-Generated Code

A repeatable method for tracking down bugs in AI-generated code — reproduce, isolate, prompt with real context, and verify with a test.

Intermediate10 min read

Browse tools for this See related prompts

Why AI-generated bugs are a different shape

Bugs you write yourself usually come from a mental model you can retrace. Bugs in AI-generated code are different — the code can look completely plausible while quietly handling an edge case wrong, because the model pattern-matched to a common solution instead of reasoning about your specific requirements. This is exactly why the honesty section on /ai-coding matters: review is not optional.

Step 1: Reproduce it reliably before touching anything

Don't ask an AI tool to fix a bug you've only seen once and can't reproduce. Find the exact input or steps that trigger it first — a fix for a bug you can't reproduce is a fix you can't verify.

Step 2: Give the AI the real error and the relevant code, not a vague description

"It's broken" produces a guess. The actual stack trace, the failing input, and the specific function produce a real fix. Paste in what you have — don't summarize it from memory.

Prompt

This function is returning the wrong total when a coupon is expired —
it should ignore the discount entirely, but it's still applying it.

Function:
[paste calculateTotal from lib/pricing.ts]

Failing case: calculateTotal([{ price: 100, qty: 1 }], "EXPIRED10")
Expected: 100
Actual: 90

Find the bug and explain what was wrong before fixing it.

Step 3: Read the explanation and the diff before accepting

A good fix comes with an explanation of what was actually wrong. If the explanation doesn't match the code that changed, or if it changed something unrelated to the bug, don't accept it — ask again with more precision.

Step 4: Add logging when the AI's fix doesn't work first try

If a fix doesn't resolve the actual failing case, don't just ask it to "try again" — give it more signal. A quick log statement at the point of failure often reveals the real problem faster than another guess would.

lib/pricing.ts

function calculateTotal(items: CartItem[], coupon?: string) {
  console.log("calculateTotal called with", { items, coupon, isExpired: isCouponExpired(coupon) })
  // ...
}

Step 5: Write a regression test so it can't come back silently

Once you understand the actual bug, turn the failing case into a permanent test. This is the step people skip most often, and it's the reason the same bug reappears three weeks later after another AI-driven change.

lib/pricing.test.ts

import { describe, expect, it } from "vitest"
import { calculateTotal } from "./pricing"

describe("calculateTotal", () => {
  it("ignores the discount when the coupon has expired", () => {
    const items = [{ price: 100, qty: 1 }]
    expect(calculateTotal(items, "EXPIRED10")).toBe(100)
  })

  it("applies the discount when the coupon is valid", () => {
    const items = [{ price: 100, qty: 1 }]
    expect(calculateTotal(items, "SAVE10")).toBe(90)
  })
})

When to debug it yourself instead of asking again

After two failed attempts on the same bug — a third identical prompt rarely produces a different result
When the bug is in logic you don't fully understand yet — debug it yourself first so you actually understand what you're shipping
Anything touching money, auth, or user data — verify the fix by reading it line by line, not by trusting a confident explanation

A pre-ship checklist for AI-touched code

The specific bug case now passes, and you verified it yourself — not just trusted the AI's word
A regression test exists for it
You read the full diff, not just the lines the AI highlighted
Nothing unrelated to the bug was changed

Tools