Microsoft's Build 2026 conference opened on June 2 with a wave of AI innovations, but one of the most impactful announcements for developers is the substantial refresh of GitHub Copilot CLI. The command-line assistant, which brings AI-powered suggestions directly into the terminal, gains a redesigned experimental terminal UI, generally available rubber-duck review, prompt scheduling commands, and local voice input. These updates transform Copilot CLI from a simple autocomplete tool into a comprehensive development partner that lives in the shell.

A Redesigned Terminal UI

The centerpiece of the refresh is an entirely new experimental terminal user interface. Gone are the days of cycling through suggestions with arrow keys in a plain text prompt. The redesigned UI integrates seamlessly with popular terminals, offering a dedicated pane that displays context-aware command completions, syntax-highlighted code snippets, and inline error explanations. This interface feels native to the terminal, blending into the developer's workflow without intrusive pop-ups.

The UI is activated by invoking gh copilot ui --experimental. Once enabled, it sits in the background, monitoring typed commands. When it detects that a user might need assistance—such as a difficult command sequence or an error message—it surfaces relevant suggestions in a draggable, resizable side panel. Developers can quickly cycle through options, see full command previews, and even edit suggestions before executing them. The design follows a minimalist philosophy, ensuring that the AI assistance is available but never distracting.

Early screenshots show a dark theme with subtle accent colors, consistent with GitHub's branding. The UI supports both light and dark modes, adapting to the terminal's color scheme. GitHub states that the experimental flag is necessary because the feature is still gathering feedback, but a stable release is expected later this year. This new interface also lays the groundwork for future multimodal interactions, such as inline code generation and visual diffs.

Rubber Duck Review Goes GA

One of the most anticipated features, rubber-duck review, has moved from limited preview to general availability. Inspired by the classic debugging technique where explaining code to an inanimate object helps uncover mistakes, this feature enables developers to have a conversational debugging session right in the terminal.

To start a rubber-duck session, a developer runs gh copilot review --rubber-duck and specifies a file or code block. Copilot CLI then reads through the code sequentially, asking clarifying questions like: \"Why is this variable set to null here?\" or \"What happens if this API call fails?\" The AI does not simply point out errors; it prompts the developer to think critically about their logic, often revealing edge cases or overlooked scenarios.

The conversation is interactive and iterative. Developers can respond with explanations, and the AI will follow up with deeper questions or suggestions. For example, in a session focused on a function that handles user authentication, Copilot might ask about token expiry handling, and if the developer indicates they hadn't considered it, the AI will propose a corrected snippet. The feature supports multiple programming languages and can analyze entire files or targeted code blocks, making it suitable for code reviews without leaving the terminal environment.

Unlike static linters or formatters, rubber-duck review feels like pair programming with a knowledgeable colleague. It's particularly beneficial for solo developers or those new to a codebase, as it encourages a thorough understanding of the code's intent. GitHub confirms that the feature uses the same underlying model as Copilot Chat but is optimized for a linear, conversational flow focused on debugging. Enterprise users can also configure the level of detail and restrict which files the AI can access for compliance purposes.

Prompt Scheduling for Automated Workflows

Prompt scheduling introduces a powerful new capability: developers can now schedule Copilot CLI prompts to run at specific times or intervals. This feature is a boon for automating routine terminal tasks. Using a cron-like syntax, you can set up prompts that execute daily, weekly, or on custom schedules.

For instance, a development team might schedule a prompt to \"check all active branches for merge conflicts with main and report them in Slack\" every morning. The command would look something like: gh copilot schedule --cron \"0 9 * * 1-5\" --prompt \"List branches with merge conflicts against main and format as a markdown report\". The output can be piped to other commands or logged to a file for auditing.

Scheduling also supports conditional execution. You can configure prompts to run only if certain conditions are met, such as if there are new commits in a repository. This is done by integrating with GitHub Actions or using webhooks. GitHub envisions this feature being used for automated security scanning, dependency updates, and even generating end-of-day summaries.

Privacy is a key consideration. Scheduled prompts are stored locally and executed on the machine where they are configured, meaning that sensitive data never leaves the device unless the prompt explicitly sends data elsewhere. This is especially important for enterprise environments that handle proprietary code. Additionally, the scheduling engine respects system sleep and power states, ensuring that jobs don't fail due to a laptop being closed.

Local Voice Input for Hands-Free Coding

In a significant move for privacy and accessibility, Copilot CLI now supports local voice input. Unlike many voice assistants that rely on cloud processing, this feature processes all voice data entirely on the device. Leveraging built-in speech recognition APIs on Windows and macOS, developers can issue natural language commands without an internet connection.

Activated via gh copilot voice --enable, the feature listens for a wake word (configurable, defaulting to \"Hey Copilot\") and then accepts commands. A developer could say, \"Show me the last ten commits by Jane,\" or \"Explain the error on line 32 of app.js,\" and Copilot CLI will present the results in the terminal pane. The voice engine can distinguish between technical terms and regular speech, understanding commands like \"grep all files containing TODO\" without misinterpreting parameters.

This local processing model ensures that no voice data is transmitted externally, addressing enterprise security concerns about eavesdropping. For developers who frequently work on remote servers via SSH, this hands-free mode is a game-changer—it allows them to interact with the terminal while using a tablet or phone, where typing might be cumbersome. The feature currently supports English, Spanish, German, French, and Japanese, with more languages planned.

GitHub has emphasized that the voice feature is not merely a novelty but a productivity tool. In testing, developers used voice commands to quickly navigate man pages, repeat complex commands, and even dictate multi-line scripts. Combined with the scheduling feature, one could speak a prompt to be executed later, blending immediate interaction with deferred automation.

Enhanced Integration with the GitHub Ecosystem

The refreshed Copilot CLI weaves more deeply into the GitHub fabric. The new UI includes shortcuts to create and comment on issues and pull requests directly from the terminal. For instance, a developer reviewing a PR can type gh pr review and the UI will present a summary of changes, with inline prompts to approve, request changes, or add comments. The rubber-duck review can be invoked on a PR diff, allowing collaborators to debug together in a shared terminal session via GitHub Code Spaces.

Enterprise features also get a boost. Administrators can now define organization-wide prompt schedules and enforce policies on voice input usage. This allows teams to standardize their terminal automations, ensuring consistency across development environments. The scheduling feature can be integrated with CI/CD pipelines, where a scheduled prompt might trigger a build if certain conditions are met.

Performance and Privacy Upgrades

Under the hood, the terminal UI is built as a lightweight extension that minimizes CPU and memory overhead. It leverages the existing GitHub CLI binary, so no additional installation is required beyond updating to the latest version (2.20.0+). The UI uses incremental updates to display suggestions without flickering, and it supports keyboard-only navigation. Local voice processing adds a negligible load, as modern devices are more than capable of handling on-device speech recognition.

Privacy remains a focal point. Beyond voice data, the rubber-duck review sessions are ephemeral by default; conversations are not stored unless the developer explicitly opts in. The scheduling engine stores prompts encrypted on disk, and enterprise admins can audit usage via GitHub's audit log. These measures address growing concerns about AI models inadvertently learning from proprietary code.

What This Means for Developers

With these updates, GitHub Copilot CLI evolves from a reactive helper into a proactive partner. The rubber-duck review encourages deeper code understanding, prompt scheduling automates the mundane, and local voice input makes interaction more natural and private. This shift aligns with a broader industry trend of embedding AI into the entire development lifecycle, not just the code editor.

For enterprise IT, the combination of on-device processing and administrative controls makes Copilot CLI a viable option even in highly regulated sectors. The ability to schedule prompts could also reduce human error in repetitive tasks, leading to more reliable maintenance routines.

Looking Ahead

The features announced at Build 2026 are rolling out immediately for Copilot CLI users with an active subscription. The experimental terminal UI is available for GitHub CLI version 2.20.0 and above, and the rubber-duck review, scheduling, and voice features are enabled by default in that release. GitHub has indicated that these capabilities will continue to improve based on user feedback, with a potential stable release of the UI by the end of the year.

As AI-assisted development matures, the command line is proving to be fertile ground for innovation. GitHub Copilot CLI's refresh shows a clear vision: making the terminal smarter, safer, and more productive without sacrificing the speed and control that developers love. The Build 2026 announcements are not just incremental updates—they represent a new chapter in how we interact with the bedrock of software development.