GitHub Copilot CLI's /rubber-duck: A Second Opinion in One Command

GitHub Copilot CLI v1.0.49 shipped on May 18 with a small command that punches above its weight: /rubber-duck. It spawns an independent reviewer agent that reads your current session — the prompts, the diffs, the test output — and returns a written critique of what the main agent is doing.

The name comes from rubber duck debugging: the practice of explaining your problem to an inanimate object until you spot the flaw yourself. Except this duck talks back.

What It Actually Does

When you type /rubber-duck, Copilot CLI pauses the main agent and launches a fresh subagent with no memory of your session except the transcript itself. That subagent reads the conversation, looks at any files the main agent touched, and writes a structured critique covering three areas: what the main agent got right, what looks risky or incomplete, and what it would have done differently.

The output lands as a system message in your session — the main agent sees it on the next turn and can adjust course. You also see it, so you can decide whether to accept the critique, override it, or stop the session entirely.

/rubber-duck

# Output (abbreviated):
# What's working:
#  - Test coverage for the new auth flow is solid
#  - Migration is reversible via the down() function
#
# Risks:
#  - The token refresh logic assumes UTC; user TZs will break it
#  - No rate limiting on the new /reset endpoint
#
# What I'd do differently:
#  - Move the JWT secret rotation into a separate PR
#  - Add an integration test for the refresh-during-logout race

When It Helps Most

The duck is best at catching things the main agent has stopped seeing — assumptions baked in early that turned out wrong, missing edge cases, and scope creep where the agent is solving a different problem than you asked for. Because the reviewer starts fresh, it doesn't share the main agent's tunnel vision.

It's also useful before merging a long session. After two hours of back-and-forth with the main agent, running /rubber-duck gives you a pre-flight check that costs roughly the same as one extra turn but catches real bugs.

When It Doesn't Help

The duck is bad at three things. First, it can't run code. Anything that requires actually executing the agent's output goes unverified. Second, it shares the main agent's context window — if the session is enormous, the duck only sees a compressed summary, which means subtle issues in the middle can vanish. Third, two LLMs from the same family share blind spots. If the main agent didn't know about a specific framework gotcha, the duck probably doesn't either.

Treat the output as a smart-but-junior reviewer's notes. Verify the duck's claims against the actual diff before you act on them.

The Other v1.0.49 Additions

Same release added /chronicle search, which lets you grep your past Copilot sessions by keyword: /chronicle search rate limiting surfaces every session where you worked on rate limits. The session list links you back to the full transcript, which is the part the duck reads.

There's also /exit print — quit the session but print the full transcript to your terminal first, so you can scroll up and grab anything you need before it disappears. And /session id, which copies the current session ID to your clipboard for sharing with teammates.

Combining /chronicle and /rubber-duck

There's a pattern emerging from early users: run /chronicle search to find a past session that solved a similar problem, copy its session ID, paste it into the current session as context, then run /rubber-duck to ask whether the current approach makes the same mistakes the old one did. It works because the duck reads transcripts cleanly and can compare two approaches without the main agent's bias toward defending its own work.

/chronicle search jwt refresh
# Returns: session id 7f2e... from 2026-03-12

# In current session:
Compare my current refresh logic to session 7f2e...
What did I do differently and why?

/rubber-duck
# Reviewer reads both and reports inconsistencies