Chapter 5: Debugging with AI

Why AI Excels at Debugging

AI brings specific strengths to debugging that complement — and sometimes surpass — human ability. Understanding these strengths helps you know when and how to leverage AI most effectively.

• Pattern suggestions — AI can connect familiar error messages with common causes and propose hypotheses to test.
• Rapid initial analysis — AI can summarize supplied code and point to suspicious areas, though it may miss context outside the material you provide.
• Multiple hypothesis generation — Instead of fixating on one theory (a common human bias), AI can propose several possible causes simultaneously.
• Alternative hypotheses — A focused prompt can ask for competing explanations, reducing the risk of testing only your first idea.

But there's a critical caveat:

Beginner vs. Senior Debugging Prompts

Focused context usually produces a more useful debugging response than a vague request, although the diagnosis still needs to be tested.

My code doesn't work, fix it

The Senior Debug Prompt Template

This template works for almost any debugging situation. Copy it, memorize it, make it automatic. The four sections give AI everything it needs for an accurate diagnosis.

Here is my code:

[paste the relevant function, component, or module]

Error message:
[paste the exact error — including stack trace]

What I'm trying to do:
[describe the intended behavior]

What happens instead:
[describe the actual behavior — error, wrong output, crash, etc.]

What I've already tried:
[list any fixes you've attempted — this prevents AI from
suggesting things you've already ruled out]

Each section serves a purpose. The code provides concrete context. The exact error narrows the search space. The intended-versus-observed gap distinguishes the failure type, while earlier experiments prevent repeated suggestions.

The Debugging Workflow

Don't jump straight to AI the moment you see an error. The most effective debugging workflow uses AI at the right moment — after you've done some initial triage yourself.

Ask for Analysis, Not Just Fixes

One of the most powerful debugging techniques is asking AI to analyze why a bug occurs rather than just fix it. This approach gives you understanding, not just a patch — and the understanding often reveals deeper issues.

Analyze why this error might occur.
Don't fix it yet — give me the three most likely causes,
ranked by probability.

For each cause, explain:
- Why it would produce this specific error
- How to verify if it's the actual cause
- What the fix would be

This prompt produces a diagnostic analysis, not just a code patch. You learn why the bug exists, which helps you prevent similar bugs in the future. It also avoids the common problem where AI suggests a fix that addresses a symptom but not the root cause.

Log-Based Debugging

When errors aren't clear-cut — when your code runs but produces wrong results — console logs become invaluable. AI is excellent at analyzing log output to trace logic flow.

Here is my function:

const filterActivities = (activities, filters) => {
  const filtered = activities.filter(a => {
    const memberMatch = !filters.members.length ||
      filters.members.includes(a.member);
    const dayMatch = !filters.day || a.day === filters.day;
    return memberMatch && dayMatch;
  });
  return filtered;
};

Here is my console output:

filters: { members: ["Alice"], day: null }
activities count: 12
filtered count: 0   // Expected: 4 activities for Alice

Why is the filter returning zero results when there
should be 4 activities matching "Alice"?

By showing AI the function, the input data, and the unexpected output, you create a precise diagnostic context. AI can often spot the issue immediately — in this case, it might identify that the member field uses full names while the filter uses first names, or that the comparison is case-sensitive.

Stack Traces: Send the Whole Thing

A common mistake is sending only the last line of an error. Include the relevant stack frames and preserve the exact message, but redact secrets, personal data, internal hostnames, and unrelated paths before sending it to an external service.

TypeError: Cannot read
properties of undefined

TypeError: Cannot read
  properties of undefined
  (reading 'map')
    at ActivityList
      (ActivityList.tsx:23)
    at renderWithHooks
    at mountIndeterminate
      Component

Where AI Excels vs. Where You Must Think

Not all bugs are equal in terms of how much AI can help. Understanding this spectrum helps you allocate your time wisely — let AI handle what it's great at, and invest your own thinking where it matters most.

The pattern is clear: AI is strongest with well-defined, pattern-based bugs (syntax, crashes, common framework issues) and weakest with bugs that require understanding business intent, system-wide architecture, or real-world performance characteristics. Your role is to bring that context.

Debugging as Dialogue

AI-assisted debugging often works as a sequence rather than a single query. Each exchange should add evidence from a log, reproduction, test, or controlled experiment; stop when the hypothesis is confirmed, not merely when the answer sounds plausible.

AI as Preventive Code Reviewer

Don't wait for bugs to appear. One of the most valuable debugging strategies is proactive — asking AI to find potential bugs before they happen.

Review this component for potential bugs.

Look specifically for:
- Null/undefined access without guards
- Race conditions in async operations
- Memory leaks (unsubscribed listeners, uncancelled fetches)
- Edge cases with empty data or missing props
- React-specific issues (stale closures, missing deps)

Don't suggest style improvements — focus only on
correctness and potential runtime failures.

This proactive approach catches bugs at their cheapest point — before they reach users, before they corrupt data, and before you spend an hour debugging them. Run this on every significant component before you consider it done.

Common Mistakes

Related Guides