Debugging With AI Agents: How to Feed Claude Code and Cursor Real Bug Context

You hand Cursor a bug: checkout throws after I apply a coupon. It reads the repo, finds the checkout handler, and confidently edits a null check. The diff looks reasonable. You ship it. The bug is still there, because the real cause was a 422 from the coupon service that returned { "discount": null }, and nothing in the source told the agent that. This is the failure mode the 2025 Stack Overflow Developer Survey put at the top of the list: 66% of developers name AI output that is “almost right, but not quite” as their single biggest frustration, and 45.2% say debugging AI-generated code takes longer than they expected.

The fix is not a better prompt. It is better evidence. An agent that can see the failing run — the replay, the console error, the malformed response — stops guessing and starts correlating a symptom to a line. This guide names the exact context contract an agent needs and shows how MCP delivers it.

Both Claude Code and Cursor are strong at reasoning over source. Cursor's codebase index, by its own documentation, “breaks your code into meaningful chunks (functions, classes, logical blocks)” and stores vector embeddings so the agent can retrieve relevant code. That is genuinely useful — and it is also the whole problem. A semantic index of source sees the shape of your program. It does not see the 500 that fired at 14:32, the response body that came back empty, or the third re-render that left a stale value on screen.

So the agent does what a junior engineer does with a vague ticket and no logs: it pattern-matches to the most plausible cause and writes that fix. Sometimes the guess lands. The survey's trust numbers show how often it doesn't — usage is climbing (84% use or plan to use AI tools) while trust erodes, with more developers actively distrusting AI accuracy (46%) than trusting it (33%). Almost-right is the default when the evidence is missing.

Think of it as a context contract. Each layer answers a question the source code can't:

• Reproduction — what did the user do? Exact steps, or better, a session replay. rrweb (“record and replay the web”) captures a full DOM snapshot plus incremental mutations, scroll, and input events with timestamps, so the session is reconstructed deterministically rather than described in prose. The agent watches the failure instead of imagining it.
• Console — what threw, and where? The literal error message and stack trace. Not “it crashed somewhere in checkout.”
• Network — what did the backend actually return? The failing request, its status code, and the response body. This is where the coupon-service 422 lives.
• Environment — under what conditions? Browser, viewport, route, feature flags. The same code path breaks on mobile Safari and passes everywhere else.

Anthropic's own Claude Code guidance points the same direction: feed the agent the symptom, the likely location, and what “fixed” looks like; paste screenshots; and pipe logs directly (cat error.log | claude) rather than describing them. Evidence beats narration.

The Model Context Protocol, revision 2025-11-25, exists to “standardize how to integrate additional context and tools into the ecosystem of AI applications,” taking explicit inspiration from the Language Server Protocol. That is the missing piece. The four evidence layers map cleanly onto MCP's primitives:

• The captured bug becomes a Resource — a single record the agent can fetch into context, carrying replay, console, network, and environment.
• Tools like get_replay, list_network_errors, or get_console_log let the agent pull a specific slice on demand instead of waiting for a human to copy-paste.
• A Prompt can template the workflow — “triage this bug: localize the fault, write a failing test, propose a patch.”

This is exactly what the BugMojo MCP server does. The browser extension captures the rrweb replay, console logs, and network requests at the moment of failure; the MCP server exposes that capture so Claude Code or Cursor reads structured evidence directly. New to the protocol itself? Start with the developer's primer on MCP, then follow the step-by-step guide to connect Claude Code to BugMojo over MCP.

Here is the honest version of the tradeoff. A semantic code index and a captured-bug context are not competitors; they answer different questions. And feeding an agent one deep bug is not the same job as monitoring production errors at scale — a dedicated monitor like Sentry beats BugMojo on long-term error trends, and that is by design.

Read the matrix two ways. Left-to-right, BugMojo is the only column that makes a single bug's full runtime context readable by an AI agent over MCP — the uncontested wedge. Top-to-bottom, BugMojo honestly loses the last two rows: if your job is aggregating exceptions across millions of requests or paging on-call at 3am, that is a production monitor's job, not ours.

Once an agent has replay, console, and network, it can do most of the work: localize the fault, write a failing test that reproduces it, and propose a patch. You should still gate the result. The MCP spec requires user consent before tools run and treats tool execution as untrusted by default, so destructive actions need approval — that is a feature, not friction. Pair it with Anthropic's advice to give the agent a check it can run (a test or a build) so the fix is verified, not merely plausible. And heed the Claude Code docs' explicit warning: don't let the agent suppress an error instead of addressing the root cause. The goal is a fast junior engineer holding the full bug report — not an autonomous committer.