Rubber Duck Thursdays

Key Concepts

• GitHub Copilot CLI: An agent-based tool that operates directly within the terminal to manage software development tasks.
• Agentic Flows: A methodology where AI agents are given specific mandates (research, planning, implementation) to perform tasks autonomously.
• MCP (Model Context Protocol): A standard that allows agents to connect to external data sources, documentation, and tools (e.g., Context 7 for up-to-date documentation).
• Plan Mode vs. Autopilot: "Plan Mode" allows the agent to brainstorm and research without modifying code; "Autopilot" grants the agent permissions to execute changes and run commands.
• Rubber Duck Review: A quality-assurance process where an agent from one model family (e.g., Claude) requests a critique from an agent of a different family (e.g., GPT) to improve output reliability.
• Microsoft Foundry: A platform for deploying and managing AI models, such as Whisper for speech-to-text.

---

1. Main Topics and Key Points

The session focused on using GitHub Copilot CLI to build features for an Electron-based to-do application called "todometer." The host demonstrated an agentic workflow:

• Research Phase: Using the research agent to identify speech-to-text libraries suitable for Electron.
• Planning Phase: Breaking down the feature request into parallel sub-tasks.
• Implementation Phase: Using "Autopilot" to execute the integration of the Whisper model.
• Review Phase: Utilizing a built-in code review agent to identify security vulnerabilities and memory leaks.

2. Real-World Applications

• Smart Car Dashboard: A community member shared their experience building a dashboard using agentic flows and zero-code tools.
• Personal Software: The host emphasized the current era of "building personal software," where developers can easily spin up custom applications to meet specific needs rather than relying on expensive or ill-fitting commercial apps.
• Open Source: The host highlighted the "Open Source Friday" series on the GitHub YouTube channel as a primary resource for new contributors.

3. Step-by-Step Methodology: Agentic Development

1. Initialization: Clone the repository using gh repo clone.
2. Context Setup: Use /mcp to enable servers (like Context 7) to ensure the agent accesses current documentation rather than relying on outdated training data.
3. Research: Invoke the research agent in plan mode to analyze requirements and potential libraries.
4. Refinement: Use specific prompts to steer the agent toward preferred infrastructure (e.g., "Use Whisper model hosted on Microsoft Foundry").
5. Review: Perform a "Rubber Duck Review" by cross-referencing the plan with a different model family.
6. Execution: Switch to autopilot to implement the code, followed by a final code review agent pass to generate a code_review.md report.

4. Key Arguments and Perspectives

• Human-in-the-loop: The host argued that while AI agents are powerful, they are prone to "hallucinations" or suboptimal code. Developers must maintain "quality gates" and use their own expertise to review AI-generated output.
• Customization is Key: To improve code review speed and quality, developers should use the Awesome Copilot repository to implement custom instructions and organizational coding standards.
• Pricing Shift: GitHub is transitioning to a token-based pricing model (effective June 1st) to improve service reliability.

5. Notable Quotes

• "Security is not an afterthought. It's something that you kind of want to think about from the get-go."
• "AI can and will make mistakes... it's up to you with your know-how, your knowledge, and your experience to be the judge of what you're getting as output."

6. Data and Research Findings

• Performance: The host noted that combining research and planning in a single agent session can significantly slow down the process; it is more efficient to run research, save the output as a markdown file, and then feed that file into a separate implementation session.
• Quality: Using a "Rubber Duck" review (cross-model family critique) can yield results near the quality of high-end models (like Claude Opus) while using more affordable models (like Claude 3.5 Sonnet).

7. Synthesis/Conclusion

The live stream demonstrated that modern development is shifting toward agent-native workflows. By leveraging the GitHub Copilot CLI, developers can automate research, implementation, and code review. However, the success of these workflows relies on three pillars: clear boundaries (using Plan vs. Autopilot modes), context management (using MCP servers), and human oversight (performing manual reviews and using custom instructions to enforce quality standards). The session concluded that while AI agents are highly capable, they function best as team members that require human guidance to ensure security and code integrity.