Slash commands in the GitHub Copilot app: a workflow primer

If you've spent time in the GitHub Copilot CLI, you know the power of a single /. In the GitHub Copilot app, slash commands take that concept in a different direction. Instead of managing terminal context, they're built around workflow control: planning, reviewing, delegating, and organizing work across sessions.

The distinction matters. CLI slash commands exist because the terminal has no visual interface—you need commands like /add-dir or /cwd to manage project context. The app handles that automatically. App slash commands are about how you drive Copilot, not where it looks.

💡 Tip: If you’ve used slash commands in the Copilot CLI, you’ll notice some familiar faces. Commands like /clear and /model work in both places. But the GitHub Copilot app-specific commands are tailored for the multi-session workflow that the desktop app provides.

Type / into the chat composer and an autocomplete menu appears, listing commands relevant to your current context. You don't need to memorize anything; the menu does the recall work. Below are the commands worth knowing and how they fit into real workflows.

Plan before you code

/plan is for the work that happens before implementation. It breaks down a task, identifies the files and components involved, and surfaces potential challenges before you write any code. It also switches the session into Plan mode, which you can select manually from the Mode dropdown.

  • New features. Break down the scope and dependencies before starting.
  • /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.
  • Large refactors. Map out an incremental approach, uncovering risks early.
  • /plan We want to refactor our notification system code to make it easier to support new channels like push notifications. Help me understand the changes needed and create an incremental migration plan.
  • Bug triage. Explore probable causes and outline diagnostic steps when you don't know where to start.
  • /plan Users are reporting that our checkout flow randomly fails after payment processing. Help me investigate possible causes and create a plan to diagnose and fix the issue.

Pressure-test ideas before committing

Rather than waiting for a code review to catch problems, /spar has Copilot play devil's advocate with your approach. It questions assumptions and points out risks or tradeoffs before you've invested hours in implementation.

  • Architecture validation. Propose a choice and have Copilot challenge your reasoning.
  • /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.
  • Option comparison. Have Copilot debate REST versus GraphQL, or async versus sync processing, based on your specific requirements.
  • /spar Help me decide between REST and GraphQL for a customer-facing API. Ask questions, challenge my assumptions, and recommend which approach fits best for an app with mobile clients.
  • Migration review. Surface edge cases and rollback concerns before starting.
  • /spar I'm migrating our database to a new managed service with minimal downtime. Poke holes in my migration plan and identify any risks or edge cases I should account for.
  • Performance analysis. Question optimizations that might introduce hidden bottlenecks or side effects.
  • /spar I'm planning to lazy load most of the components on my site to improve initial load time. Critique my approach and tell me where it could hurt user experience or introduce unnecessary complexity.

Hand the wheel to Autopilot

Once planning is done, /autopilot handles execution. Give Copilot a goal and let it identify the files, implement changes, and update tests without you managing each step. This command also activates Autopilot mode, available via the Mode dropdown.

  • Feature implementation. Delegate a full task from specification to test updates.
  • /autopilot Add support for exporting user reports as CSV files. Identify the files that need changes, implement the feature, and update any relevant tests.
  • Multi-step maintenance. Hand off dependency upgrades, refactors, or documentation updates.
  • /autopilot Update this project to the latest version of React. Identify breaking changes, update the code where needed, and make sure the test suite passes.

Get a second opinion

/rubber-duck is a built-in independent reviewer. It uses a different model to look over your work, catching assumptions and blind spots your primary model may miss. It's a freshness check for complex work: refactors, architectural choices, or migration plans where the cost of a missed edge case is high.

  • Plan review. Have a second model evaluate your implementation plan before writing code.
  • /rubber-duck Review the implementation plan we've created for adding two-factor authentication. Identify any blind spots, edge cases, or risks that we may have overlooked.
  • Refactor critique. Get feedback on architectural concerns or unnecessary complexity before opening a pull request.
  • /rubber-duck Review the refactoring we've completed for the notification system. Look for architectural concerns, unnecessary complexity, or areas that could be improved before I open a pull request.
  • Migration validation. Independently assess rollback concerns and reliability risks.
  • /rubber-duck Review our database migration plan and implementation. Point out any blind spots, rollback concerns, or edge cases we should address before deployment.

Transform conversation into interaction

Long chat exchanges aren't always the clearest way to absorb information. /create-canvas converts a discussion into an interactive interface—a visualization, dashboard, or workflow you can manipulate directly.

  • /create-canvas Create an interactive diagram showing how services in this application connect.
  • /create-canvas Create an issue triage board that lets me review and categorize open issues.

Coordinate parallel work

Some tasks span multiple repositories or require several distinct workstreams to advance at once. /orchestrate splits a bigger effort into smaller tasks Copilot can coordinate across sessions and codebases.

  • Cross-repository changes. Track work that touches frontend, backend, and shared codebases together.
  • /orchestrate I need to add support for a new authentication flow across our frontend, backend, and shared repositories. Help me break down the work and coordinate the changes needed in each codebase.
  • Release preparation. Divide implementation, testing, documentation, and deployment into coordinated efforts.
  • /orchestrate Prepare this feature for release. Identify the work needed for implementation, testing, documentation, and deployment, then help coordinate each task.

No command list to memorize—just type / and explore what's available. Start with a few that match your workflow and build from there. The full command reference is available in the GitHub Copilot app documentation, and general app details live in the docs as well.