Rider Debug

rider-debug

A Claude Code skill + CLI that lets an AI agent drive Rider's MCP debugger against a running Unity Editor — set breakpoints, inspect variables, step execution — without restarting the agent session.

Why

Two questions I wanted to answer:

1. Can an agent automate debugging on its own?
2. Can an agent prove a hypothesis by stepping through a live process,

instead of only reading the code?

This is personal R&D. I haven't leaned on it in production work yet — most of the bugs I hit there are hard to reproduce and the per-session token cost is high. I expect to actually use it in my own side projects when the chance comes up.

Design notes

It's a thin wrapper over the [Debugger MCP Server][plugin] plugin, but the wrapping is the point:

• No MCP registration. A registered MCP server loads its tool definitions

into context and has to be active — and activating one mid-session means starting a new session. This connects to the debugger over SSE + JSON-RPC on demand, so the agent can start debugging in the session it's already in.

• Token-filtered output at the CLI layer. Variable dumps and tool catalogs

are condensed before they reach the model (get_vars --simple --names=..., a 24h schema cache), so a debugging loop doesn't burn context.

This is the same idea Anthropic describes in [Code execution with MCP][anthropic]: wrap MCP tools in code so their definitions aren't all loaded upfront and intermediate results are filtered before they hit the model context.

What's mine vs. what it depends on

• Depends on: the [Debugger MCP Server][plugin] plugin — the actual

debugger engine (breakpoints, variable reads, execution control). Note the plugin lists Rider as untested; this skill wires it to a Rider + Unity setup, which is where the limitation below surfaced.

• What's here: a spec-compliant SSE + JSON-RPC client, the on-demand

connection that skips MCP registration, output filtering / schema caching, and convenience wrappers (batch breakpoints, variable name filters).

Usage

python3 rider-cli check                                   # connectivity check
python3 rider-cli list_tools                              # tool list (24h cache)
python3 rider-cli  '{"key":"val"}'                  # call a debugger tool

Typical flow:

1. check → if it errors, make sure Rider is running with the Debugger MCP

Server plugin.

1. list_run_configurations → start_debug_session '{"configuration":"Attach to Unity Editor"}'
2. set_breakpoint '{"project_path":"...","file_path":"...","line":42}'

(conditional: add "condition":"...", logpoint: add "log_message" + "suspend_policy":"none", batch: batch_breakpoint '[...]')

1. On hit: get_vars '{"session_id":"ID"}' --simple --names=foo,bar,

get_stack_trace

1. Control: resume_execution, step_over, step_into, step_out
2. Cleanup: remove_breakpoint, stop_debug_session

See [SKILL.md](SKILL.md) for the full agent-facing instructions.

Limitations

• evaluate_expression / set_variable time out against Unity. Workaround:

read with get_variables, edit in the Rider UI, or use logpoints (log_message + suspend_policy:"none").

License

[Apache 2.0](LICENSE).

[plugin]: https://plugins.jetbrains.com/plugin/29233-debugger-mcp-server [anthropic]: https://www.anthropic.com/engineering/code-execution-with-mcp

Source & license

This open-source MCP server is cataloged on AgentStack and links to its original source — we do not rehost the code.

• Author: yhc509
• Source: yhc509/rider-debug
• License: Apache-2.0

Install and usage instructions live in the source repository linked above.