If you’ve ever explained a bug out loud to a rubber duck sitting on your desk and suddenly realized the problem mid-sentence, you already understand the core idea. Now GitHub and Microsoft have turned that classic debugging technique into a built-in AI agent. The Rubber Duck agent doesn’t just listen—it reviews your coding agent’s plans, code, and tests with a genuinely different perspective and hands back concrete, actionable feedback.
This isn’t another chatty assistant that agrees with everything. It’s a deliberate second-opinion system designed to catch the things the primary model misses. And as of Visual Studio Code 1.135 (released late August 2026), it’s available right inside your editor when you use GitHub Copilot agents.
The Classic Technique, Upgraded
Rubber duck debugging has been around for decades. The story goes that a developer would keep a small rubber duck on their desk. When stuck, they’d explain the code line by line to the duck. The act of articulating the problem often revealed the flaw. The duck itself never said a word—that was the point. The value came from forcing clear thinking.
GitHub’s Rubber Duck agent keeps the spirit but flips the silence. It listens to what the main coding agent is proposing, then responds with structured critique. Importantly, it runs on a different AI model family than the one driving your session. If your main agent is using a Claude model, the Rubber Duck might use a GPT model (or vice versa). This design choice is intentional. Models from the same family tend to share similar blind spots. A complementary model is more likely to notice different issues—logic gaps, edge cases, security concerns, or design weaknesses the first model simply didn’t surface.
The agent is strictly read-only. It examines plans, implementations, and tests. It does not edit files or run commands that change your environment. The main agent remains in charge of deciding what to do with the feedback.
What the Rubber Duck Actually Looks For
When consulted, the Rubber Duck agent does several specific things:
- It reads the current work in full context—what the change is trying to accomplish and how it fits into the larger codebase.
- It searches for real problems: logic errors, design flaws, security vulnerabilities, missing test coverage, performance bottlenecks, and other issues that could cause the task to fail or create maintenance headaches later.
- It categorizes findings by severity: blocking issues (must be fixed), non-blocking issues (should be fixed for quality), and suggestions (useful improvements that are lower priority).
- It stays focused. The agent is instructed not to nitpick style, naming, formatting, or minor best-practice advice that doesn’t affect correctness or robustness. If it finds nothing important, it says so clearly.
This focused approach makes the feedback more useful than a generic “review this code” request. You’re less likely to drown in low-value comments.
How Copilot Uses It Automatically
In both GitHub Copilot CLI and VS Code, the main agent is encouraged to consult the Rubber Duck at high-leverage moments rather than only when stuck. Typical trigger points include:
- After creating a plan for a non-trivial change, before starting implementation. This is often the highest-value moment—design flaws are cheap to fix on paper and expensive once code is written.
- During complex multi-file implementation work.
- After writing tests, to check whether coverage actually matches the intended behavior.
- When the agent encounters repeated failures or unexpected results, so it can get an independent analysis instead of retrying the same approach.
For small, obvious changes, Copilot usually skips the review. That keeps the feature from adding unnecessary latency to simple tasks.
When the Rubber Duck is consulted automatically, you typically see a summary in the conversation timeline rather than the full raw critique. Something like: “The critique pointed out a blind spot around X, so I updated the plan to address it.”
Using Rubber Duck in Visual Studio Code — Step by Step
Here’s the practical side. The feature lives inside Copilot agent sessions in VS Code 1.135 and later.
1. Make sure you’re set up correctly
You need:
- VS Code 1.135 or newer
- An active GitHub Copilot subscription
- A Copilot agent session (not ordinary Chat mode)
Open the Chat view with Ctrl+Alt+I (Windows/Linux) or Cmd+Alt+I (macOS), or open the Agents window. Start a new session and choose the Copilot harness/Session Target. Confirm you’re working in Agent mode rather than Ask or Plan mode if those options are available.
The Rubber Duck only works when the main session is using a Claude or GPT model and a suitable complementary model is available. If your primary model doesn’t qualify, the feature simply won’t activate.
2. Let it run automatically
For most non-trivial tasks you can simply work as usual. When the agent decides a second opinion would help, it will consult the Rubber Duck behind the scenes and incorporate the feedback. Watch the timeline for indications that a critique happened.
3. Request a review manually (recommended for control)
You have two clean ways to force a review at any moment.
Natural language works well. Just type prompts such as:
- “Get a second opinion on the changes you made so far.”
- “Rubber duck your plan.”
- “Critique the current implementation for edge cases and design issues.”
- “What are the biggest risks in this approach?”
The slash command is more precise:
/rubber-duckor with a focused question:
/rubber-duck What edge cases are missing?/rubber-duck Review this for security and concurrency issues/rubber-duck Is the test coverage adequate for the new behavior?You can invoke this after planning, midway through implementation, after tests are written, or whenever something feels off. The agent will hand the relevant context to the Rubber Duck, receive the categorized feedback, summarize it for you, and then decide how to proceed.
4. Understand the interaction flow
The Rubber Duck never makes changes itself. After receiving the critique, the main Copilot agent typically:
- Summarizes the key findings
- Decides which items to address
- Updates its plan or code accordingly
- Continues the task
You stay in the loop. You can agree, disagree, or ask for clarification on any of the points raised.
Practical Tips for Getting the Most Out of It
- Use it early on design-heavy work. Catching a flawed approach before implementation saves the most time.
- Be specific in your manual prompts when you have a particular concern (security, concurrency, error handling, API contracts, etc.).
- Remember it adds latency and model usage. The extra cost is usually worthwhile on complex tasks but unnecessary for tiny edits.
- Treat the feedback as expert input rather than absolute truth. The complementary model can still be wrong, just in different ways than the primary model.
- Combine it with good agent habits: clear task descriptions, solid test expectations, and reviewing the final diff yourself.
Benefits and Realistic Limitations
The biggest advantage is reduced single-model blindness. Two different model families looking at the same problem increase the chance of spotting issues that would otherwise slip through. Early critiques also tend to prevent wasted work on flawed designs.
Limitations are worth knowing. The feature is experimental. Availability depends on the models in use. It only reviews; it doesn’t implement fixes. And because it runs an extra model pass, sessions can feel slightly slower when it activates frequently.
Still, for anyone doing non-trivial coding with AI agents, having a built-in critic that speaks a different “language” is a meaningful quality boost.
Why This Matters Beyond the Feature
AI coding tools have moved quickly from autocomplete to full agents that plan, edit, test, and iterate. As those agents take on more complex work, the risk of confident but incomplete solutions grows. A deliberate second-opinion mechanism is one practical way to push back against that risk without slowing the entire workflow to a crawl.
The Rubber Duck agent is also a nice example of product thinking that respects an old developer tradition. Instead of inventing a brand-new metaphor, the team took something many programmers already do and made it useful at machine scale.
If you spend time in VS Code with Copilot agents, try the feature on your next non-trivial task. Plan something reasonably complex, then either wait for the automatic consultation or type /rubber-duck yourself. Seeing a different model surface a real gap in the plan is oddly satisfying—and often saves more time than it costs.
The classic rubber duck on the desk still works, of course. But now you have one that talks back, and it lives inside the editor you already use every day.