Usage Guide

"Set a breakpoint on line 42 of main.py"
"Add a breakpoint at the start of calculate_total()"

"Start debugging with these breakpoints"
"Run the debugger and pause at the first breakpoint"

"Show me the value of user_input"
"What are all the local variables?"
"Display the stack trace"

"Step over the next line"
"Step into this function call"
"Step out of this function"
"Continue until the next breakpoint"

User: "This function returns the wrong value. Help me find the bug."

AI: I'll set a breakpoint at the function entry and step through:
1. Setting breakpoint at line 15...
2. Starting debugger...
3. [Paused at line 15]
4. Current value of input: [1, 2, 3]
5. Stepping through...
6. Found the issue: You're dividing by zero when the list is empty.

User: "How does this recursive function work?"

AI: Let me step through a few iterations:
1. Setting breakpoint at recursion entry...
2. Starting with input: 5
3. [First call] n=5
4. [Second call] n=4
5. [Third call] n=3
...

User: "When does this variable change?"

AI: I'll set a conditional breakpoint:
"Set breakpoint on line 30 with condition: count > 10"

"Set a breakpoint on line 42, but only break when x > 100"
"Add a breakpoint that only triggers after 5 hits"

"Add a log point on line 30 that prints the value of total"

"Add a watch expression for user.name"
"Monitor the value of count throughout execution"

"Evaluate: len(data) * 2"
"What's the result of: user.age + 10?"

def process_data(items):
    result = []
    for item in items:  # Breakpoint here
        processed = item * 2
        result.append(processed)
    return result

fn calculate_sum(numbers: &[i32]) -> i32 {
    let mut sum = 0;  // Breakpoint here
    for &num in numbers {
        sum += num;
    }
    sum
}

function fetchUserData(userId) {
  const response = fetch(`/api/users/${userId}`); // Breakpoint here
  return response.json();
}

1. Set breakpoint at function entry
2. Step through line by line
3. Inspect variables at each step
4. Find where behavior diverges from expected

1. Set breakpoint where error occurs
2. Check stack trace
3. Set breakpoints up the call chain
4. Find where bad data originates

1. Set breakpoint in middle of suspect code
2. Check if bug already present
3. Move breakpoint up or down
4. Repeat until bug location narrowed down

User: "Set a breakpoint at line 15"
AI: [Sets breakpoint and starts debugging]
User: "Now step into the function call"
AI: [Steps in]
User: "What's the value of result?"
AI: [Shows value]