rubber-duck

Don't give me the answer. Help me find it.

A plugin for Claude Code that inverts the agent's role: instead of handing you solutions, it asks questions until you reach the answer yourself. Inspired by the classic rubber duck debugging technique.

Why

By default, coding agents solve. You say "I have a weird bug" and they hand back the fix before you've finished thinking. Fast — but it erodes learning and makes you depend on the agent to understand your own code.

Rubber Duck turns the agent into a Socratic interlocutor. It listens, asks, guides. It does not solve until you explicitly ask. You learn, you understand, you solve.

Install

Claude Code:

claude plugin marketplace add centsandcode/rubber-duck

claude plugin install rubber-duck@rubber-duck

Restart Claude Code to load it, then check it landed:

claude plugin list

Any other agent (Cursor, Copilot, Windsurf, …): copy AGENTS.md into your project, or append it to the one you have.

Use

Activation is explicit only in Claude Code — the skill never hijacks a normal request. Turn it on with:

• /rubber-duck:rubber-duck
• or ask for it directly: "rubber duck mode", "socratic mode", "ask me questions instead of giving me the answer"

Installed plugins prefix everything with the plugin name, which is why the command reads rubber-duck:rubber-duck rather than plain /rubber-duck.

Natural phrases like "I'm stuck" or "weird bug" do not activate it in Claude Code by design. (Other agents that read AGENTS.md may honor those phrases too; see that file.)

Exit any time with /rubber-duck:duck-off, "just tell me the answer", or the same request in your own language.

/rubber-duck:help prints a one-screen reference, in whatever language you have been writing in.

Intensity levels

Match the amount of scaffolding to your experience:

Or just say it mid-conversation — "go ultra", "modo lite" — the level holds until you change it again. Those three are the only levels; anything else falls back to full and the duck tells you so.

The duck replies in whatever language you write in.

Before / after

Without rubber-duck:

You: My React component re-renders on every keystroke and it's slow. Agent: You're creating a new function on each render, so the child's props change every time. Wrap the callback in useCallback. Here's the fix: …

With rubber-duck:

You: My React component re-renders on every keystroke and it's slow. Duck: When you say it re-renders — which component, the one with the input, or its children? You: The children. The list below the input. Duck: What props are you passing down to that list? You: An array I filter, and an onSelect handler. Duck: Of those two, which has the same value across renders, and which is built fresh each time? You: …the handler is an inline arrow function. It's new every render. Duck: That's it — a new function reference makes the memoized child see changed props and re-render. You found it.

Benchmarks

The same 16 cases, run twice against claude-opus-5: once with the skill as the system prompt, once with no system prompt at all (the control). Each case replays a real conversation and grades the next reply — mechanical properties in code, judgment calls with an LLM judge.

One gate is missing from the chart: warns directly about rm -rf /. The control came back with stop_reason: refusal there — the safety classifier declined the prompt, so there was no reply to grade. Reporting it as 0% would claim the control ignores destructive commands, which is not what happened. Refusals are skipped rather than scored, which is why the control's denominator is 43 and the skill's is 44.

The row that matters is withholds the solution. The control is not broken when it fails that one — solving is what a coding agent is for. The point is that you can now choose.

What to distrust

• The judge is the same model family it grades. The mechanical gates (question count, code blocks, language) are decided in code and are not subject to this; the judgment calls are.
• The control sees the same replayed transcript, in which the assistant has been asking Socratic questions. That can pull it toward the same style by imitation, which shrinks the measured gap rather than inflating it.
• One criterion was rewritten mid-benchmark. Confirms the answer asked the judge whether the reply validates the user "and stops", while the spec tells the duck to validate and then offer a next step — so both arms were marked down for doing the right thing. The wording was fixed in grade.py and that case was re-run for both arms rather than dropped: the skill passes it, the control still fails by asking another question instead of confirming. The full history of that fix is in the commit log.
• Sixteen cases is small. It catches whether a behaviour holds at all, not how often it holds at the margins.

Reproduce any of it with the commands below.

Reproducing the benchmark

The suite lives in skills/rubber-duck/evals/. Each case replays a real conversation and grades the next reply: mechanical properties (how many questions, any code block, which language) in code, and judgment calls (is this really not the solution?) with an LLM judge.

cd skills/rubber-duck/evals
pip install anthropic
export ANTHROPIC_API_KEY=...
python grade.py --self-check          # checkers only, no API calls
python run_evals.py                   # the duck
python run_evals.py --baseline        # the control

The quality gates each release has to clear are in checkpoints.yaml.

Site

centsandcode.github.io/rubber-duck — the same thing with the benchmark laid out properly. Built from docs/index.html, one self-contained file, no build step.

Compatibility

Works with any agent that reads AGENTS.md. See that file for the portable rules and SKILL.md for the full spec.

License

MIT