Python Debugging — The Bug Hunter Path

Explain unfamiliar code intent from structure and names

Summarize what a code snippet is trying to do before executing or editing it.

Trace data and control flow by hand

Follow values, branches, calls and returns to produce a correct execution trace.

Identify hidden assumptions and preconditions

State the input, type and state assumptions that must be true for the code to behave correctly.

Predict stdout and return values

Predict observable output and returned values without running the program.

Predict the exception before Run

Identify the likely exception type and failing operation before execution.

Track state changes across execution

Track mutations and bindings so the final program state is explicit.

Locate prerequisite weakness from evidence

Use diagnostic mistakes to identify the exact Python prerequisite that needs review.

Repair a small failure without redesigning

Make the smallest correct change that restores the intended behavior.

Explain why the repair works

Describe the root cause, the fix, and what prerequisite knowledge prevented the mistake.

Separate symptom from root cause

Distinguish what the user observes from the underlying defect that produces it.

Define expected versus actual behavior

Write a precise expected/actual comparison that can be verified.

Collect evidence before editing code

Choose the most relevant code, input, traceback, log or state evidence before changing anything.

Reproduce the bug reliably

Create repeatable steps and inputs that trigger the same failure.

Form a testable debugging hypothesis

Turn an observation into a hypothesis that predicts what evidence should appear.

Change one variable at a time

Design an investigation step that isolates one factor without introducing new uncertainty.

Detect wrong comparison and arithmetic operators

Find operator choices that produce valid code with incorrect results.

Reason through compound boolean expressions

Evaluate and simplify and/or/not conditions to expose logical mistakes.

Repair branching without breaking other cases

Fix conditional logic and verify preserved behavior across representative cases.

Detect off-by-one and loop-bound errors

Identify incorrect start, stop and iteration conditions in loops.

Find premature return, break and continue bugs

Trace control flow to detect paths that terminate or skip work too early.

Verify every intended path executes

Use targeted inputs to prove loop and return behavior across branches.

Resolve local, global and nonlocal bindings

Predict which binding Python reads or writes in nested scopes.

Distinguish reassignment from mutation

Explain whether code changes a binding or mutates an existing object.

Debug scope-related state surprises

Use scope evidence to fix unexpected values without unnecessary globals.

Detect aliasing and shared references

Identify when two names refer to the same mutable object and predict side effects.

Trace list and dictionary mutation

Track in-place changes across functions and containers to locate unintended state changes.

Choose safe copying or ownership boundaries

Use copying or clearer ownership only where needed to prevent shared-state bugs.

Place breakpoints at decision boundaries

Choose breakpoint locations that maximize information instead of stopping everywhere.

Use step into, step over and continue deliberately

Select the execution-control action that answers the current debugging question.

Build a breakpoint investigation plan

Sequence stops and observations so each pause tests a hypothesis.

Read the call stack as a story

Use frames to understand how execution reached the current line.

Inspect locals and object state safely

Examine values and identities without accidentally changing the state being investigated.

Compare frames to locate state corruption

Find the frame where a value first diverged from its expected state.

Convert a bug report into a failing test

Translate the reported symptom into deterministic input and expected behavior.

Write the smallest test that proves the bug

Remove unrelated setup while preserving the exact failure signal.

Keep the test red before changing production code

Verify the test genuinely detects the bug before attempting a fix.

Write precise assertions for behavior

Choose assertions that fail for the right reason and communicate expected behavior.

Isolate tests from shared state and side effects

Prevent order dependence, leaked state and external noise from hiding the real failure.

Use exception checks and basic mocks purposefully

Test failures and boundaries while mocking only dependencies that obstruct deterministic evidence.

Define a function contract

State valid inputs, outputs, side effects and failure behavior before debugging a function.

Debug arguments, defaults, *args and **kwargs

Find binding and default-value mistakes in function calls and definitions.

Verify return-value behavior across paths

Detect missing, premature or inconsistent returns using targeted cases.

Explain closure capture and lexical scope

Trace which outer variables a nested function captures and when their values are resolved.

Detect late-binding bugs in generated callbacks

Recognize loop-created closures that all reference the same final binding.

Repair captured state intentionally

Bind the intended value and verify each closure behaves independently.

Detect forgotten await and coroutine misuse

Recognize coroutine objects, missing awaits and incorrectly scheduled async work.

Find blocking work inside async code

Identify synchronous operations that stall the event loop and degrade responsiveness.

Verify async fixes without hiding timing bugs

Use deterministic checks and explicit scheduling expectations to validate behavior.

Recognize race-condition symptoms

Identify nondeterministic behavior that depends on timing or interleaving.

Trace shared-state access across workers

Map reads and writes to shared data to locate unsafe interleavings.

Choose a synchronization or ownership fix

Select locking, isolation, immutability or ownership changes that address the actual race.

Read a diff for behavioral risk

Compare changed code with surrounding behavior to identify what could break beyond the edited lines.

Spot hidden edge cases and unsafe mutation

Identify missing boundaries, shared-state hazards and assumptions introduced by a change.

Write an actionable review comment

Explain the risk, evidence and a concrete verification request without prescribing unnecessary redesign.

Add defensive checks at real boundaries

Validate assumptions where invalid data can actually enter or cross a contract.

Request the right regression protection

Connect a discovered risk to the smallest useful automated test.

Balance clarity, safety and complexity

Reject fixes that hide the bug or add complexity without improving correctness.

Turn a user symptom into an incident statement

Describe impact, scope, expected behavior and evidence without jumping to a fix.

Estimate blast radius from evidence

Determine which users, requests or data paths are affected based on available signals.

Choose the first high-value inspection

Select the safest evidence source that can most reduce uncertainty.

Correlate logs, traceback and recent changes

Build one evidence timeline from runtime signals and code history.

Rank competing root-cause hypotheses

Prioritize hypotheses by how much evidence they explain and what they predict next.

Reject a plausible but unsupported hypothesis

Use contradictory evidence to eliminate a tempting wrong explanation.

Reproduce and prioritize a multi-bug system

Create a debugging plan for interacting logic, exception, state, edge-case and performance failures.

Fix, test and protect the final codebase

Implement verified repairs and add regression tests without breaking correct behavior.

Defend the root-cause analysis independently

Explain evidence, discarded hypotheses, final fixes and remaining risks with minimal or no AI guidance.

Explain unfamiliar code intent from structure and names

Summarize what a code snippet is trying to do before executing or editing it.

Trace data and control flow by hand

Follow values, branches, calls and returns to produce a correct execution trace.

Identify hidden assumptions and preconditions

State the input, type and state assumptions that must be true for the code to behave correctly.