Debugging is where developers expect the most help and where the division of labour is sharpest. The assistant is useful at one end of the process and nearly useless at the other.
What debugging actually consists of
The work is establishing what the system is doing, which differs from what the developer believed it was doing.
That requires observation: reading state, adding logging, reproducing conditions and narrowing down where behaviour diverges from expectation.
Almost all of that information exists only at runtime, in a system the assistant cannot see.
Where the assistant is genuinely strong
Interpreting an unfamiliar error message is fast and reliable, since these messages are extensively documented and discussed.
Generating a list of plausible causes for a described symptom is also good, and the list frequently includes something the developer had not considered.
Explaining what an unfamiliar piece of code does, so the developer can reason about it, is a third case where the code itself contains the answer.
Why hypotheses need pruning
An assistant asked what could cause a symptom produces a broad list ranked by how commonly each cause is discussed rather than by how likely it is here.
The developer knows things that reorder that list immediately: what changed recently, which components are already suspect, what the deployment history looks like.
Supplying those facts in the request produces a far more useful ranking, and omitting them is the most common reason the suggestions feel generic.
Why the confident wrong answer is costly here
An assistant given a symptom will identify a cause with full confidence, and following that lead can consume hours.
Debugging is unusually vulnerable to this, because a plausible explanation reduces the pressure to gather more evidence.
The habit that protects against it is confirming the mechanism before acting on it, which usually takes one measurement and prevents a long detour.
What changes with runtime access
Assistants that can execute code, read logs and inspect state close the observation gap and become substantially more useful.
With the ability to run an experiment, the assistant can distinguish between its own hypotheses rather than presenting them all as equally likely.
That capability also introduces the obvious risk, since a system that can run commands against a live environment to investigate a fault can also make the fault considerably worse.