AIToday
AI Coding AssistantsGitHub Blog (AI)Published: Aug 7, 2026, 06:00 JST4 min read

GitHub Copilot app adds slash commands for faster workflows

GitHub Copilot app adds slash commands for faster workflows

Key takeaway

  • GitHub has launched slash commands in its Copilot desktop app to speed up developer workflows.

  • These text shortcuts—typed directly into the chat composer—offer quick access to features like task planning, idea validation, automated implementation, peer review from a second AI model, interactive visualization creation, and multi-repository coordination.

  • The commands are tailored to the visual interface of the desktop app and are discovered via autocomplete when developers type the / character.

3 Key Points

  1. What happened

    GitHub has introduced slash commands in its Copilot desktop app—text shortcuts that activate context-aware features like /plan (break down tasks before coding), /spar (pressure-test ideas), /autopilot (automate implementation steps), /rubber-duck (get a second opinion from a different model), /create-canvas (turn conversations into interactive diagrams), and /orchestrate (coordinate work across multiple repositories).

  2. Why it matters

    These commands let developers skip menu navigation and keep focused on their work. Unlike CLI slash commands (which manage terminal access), app commands are designed around the visual, multi-session workflow of the desktop app—helping teams move faster through planning, validation, implementation, and cross-repository coordination.

  3. What to watch

    Users can explore commands by typing / in the chat composer, where an autocomplete menu shows available options. GitHub's documentation and blog posts provide deeper guidance on each command and use cases.

In Depth

Read the full story

GitHub has expanded its Copilot desktop app with six key slash commands designed to streamline different phases of the development workflow. Each command addresses a specific need and can be discovered by typing / in the chat composer, where an autocomplete menu reveals available options.

The /plan command helps developers break down tasks before writing code. It switches the session into Plan mode and is useful for planning new features (identifying files, components, and dependencies), preparing for large refactors (mapping out complex changes and uncovering risks), and triaging bugs (exploring possible causes and outlining diagnostic steps). For example, a developer can type "/plan I need to add two-factor authentication to our application. Help me break down the work involved, identify what files need to change, and outline an implementation approach" to get structured guidance before implementation begins.

The /spar command acts as a devil's advocate, pressure-testing ideas by having Copilot question assumptions and point out potential risks or trade-offs. It can be used to validate architecture choices (e.g., using Redis for caching), compare implementation options (REST versus GraphQL), review migration plans, or challenge performance optimizations. A developer might use it like "/spar I'm planning to use Redis as a caching layer for our product API. Challenge my approach and point out any scalability or consistency concerns I may have missed."

Once a plan is ready, /autopilot takes over to handle implementation. It switches the session into Autopilot mode and helps developers work through implementation steps and iterate. It can be used to implement new features by handing off a task and letting Copilot work through the steps, or to complete larger maintenance tasks like updating dependencies or refactoring code.

The /rubber-duck command provides a second opinion by using a different model to independently review work. It surfaces blind spots, questions assumptions, and catches issues the primary model may have missed—particularly valuable for complex refactors, architectural decisions, and migration plans. Unlike the primary model, this fresh perspective helps validate work before a pull request is opened or a deployment moves forward.

The /create-canvas command turns conversations into interactive experiences. Instead of scrolling through chat, developers can create visualizations, dashboards, or custom workflows they can interact with—such as interactive diagrams showing service connections or issue triage boards for categorizing open issues.

Finally, /orchestrate coordinates work across multiple repositories. It breaks larger efforts into smaller tasks that can move forward in parallel, helping developers track and coordinate updates when a feature touches multiple codebases or when larger projects require work across implementation, testing, documentation, and deployment. The article notes that users do not need to memorize commands; typing / and exploring the autocomplete menu is sufficient to get started.

Context & Analysis

GitHub's introduction of slash commands in the Copilot desktop app represents a shift in how developers interact with AI coding assistants within a visual, project-aware environment. The article distinguishes these commands from their CLI predecessors by noting that the app's visual interface handles project context automatically, eliminating the need for file and directory management commands. Instead, the app-level commands focus on workflow orchestration—planning, validation, implementation, and coordination—reflecting the multi-session and multi-repository capabilities unique to the desktop application.

The design philosophy emphasizes reducing friction: rather than navigating menus or breaking focus to find tools, developers can type a single character (/) and access the exact workflow they need. Commands like /plan and /spar address the planning and validation phases before code is written, while /autopilot and /rubber-duck handle implementation and peer review. The addition of /orchestrate signals GitHub's recognition that modern development often spans multiple codebases, requiring tools that can coordinate work across repositories. By surfacing these commands through autocomplete, GitHub lowers the barrier to discovery—users need not memorize commands but can learn them organically as they work.

FAQ

How do I use slash commands in the GitHub Copilot app?
Type / directly into the GitHub Copilot app's chat composer, and an autocomplete menu will appear showing the commands available in your current context.
What is the difference between Copilot CLI slash commands and app slash commands?
CLI slash commands are designed around terminal workflows—managing directories, setting working directories, and terminal access. App slash commands are tailored for the desktop app's visual, multi-session workflow and focus on tasks like navigating sessions, managing projects, and controlling agent behavior. Some commands like /clear and /model work in both places.
What does /rubber-duck do?
It uses a different model to independently review your work, helping surface blind spots, question assumptions, and catch issues your primary model may have missed—useful for complex refactors, architectural decisions, and migration plans.
GitHub Blog (AI)Read Original Article

Get the latest AI Coding Assistants news every morning

AI-summarized, only the topics you pick — one digest a day via Email, Slack, or Discord.

Free · takes 30 seconds · unsubscribe anytime

Ask AI

Ask AI anything about this article. Q&As are published on this page for other readers too.

Related Articles

Next articleSuno adds watermarks to AI music, seeks legal ground amid lawsuits

The AI news that matters, in one minute each morning.

Sign up free