Master GitHub Copilot CLI Slash Commands for Faster Coding

GitHub Copilot CLI transforms the terminal into a powerful coding assistant, but its true potential lies in slash commands. These built-in controls let developers manage sessions, switch models, and inspect changes—all without leaving the command line.

These commands act as your command center, providing direct control over Copilot’s behavior and context. Whether you’re refactoring code, planning features, or resuming past sessions, slash commands streamline workflows and reduce friction. To explore all available options, simply type / in your terminal to open a scrollable menu of supported commands.

Why slash commands matter in Copilot CLI

Slash commands serve as the bridge between developer intent and AI assistance. They enable precise control over how Copilot processes tasks, helping you:

• Guide Copilot’s behavior with specific instructions.
• Inspect changes before applying them to your codebase.
• Manage context to avoid exceeding token limits.
• Resume past sessions without restarting from scratch.
• Maintain clean permissions across different projects.

Think of them as shortcuts to efficiency. Once mastered, they turn Copilot CLI from a reactive tool into a proactive collaborator.

Switching models on the fly

Different coding tasks demand different AI strengths. GitHub Copilot offers multiple models, each optimized for specific workloads:

• Lightweight models excel at quick refactoring or syntax corrections.
• Reasoning models handle deeper tasks like architectural planning or complex debugging.
• Plan-based models are ideal for feature development or large-scale changes.

To switch models, type /model in your terminal. The system displays available options, including:

• Capabilities for each model (e.g., speed vs. reasoning depth).
• Plan-specific availability based on your subscription or organization settings.
• Cost multipliers to help balance performance and usage within your plan.

Selecting the right model upfront saves time and reduces unnecessary iterations.

Managing context and token limits

Copilot CLI operates within a fixed context window, which limits the amount of information it can retain during a session. To check your current usage, run /context. This command displays:

• Remaining token count.
• System resource consumption.
• Available buffer space for new inputs.

When you’re running low, use /compact to summarize the current conversation and free up space. While Copilot CLI automatically compresses context when nearing limits, manual compaction gives you control over when to transition to new tasks. For a complete reset, /clear erases the session entirely, clearing all accumulated context.

Resuming past sessions and inspecting changes

Switching between projects or tasks often means losing progress—but not with Copilot CLI. To resume a previous session, type /resume. The system presents a list of recent sessions, both local and remote, allowing you to pick up exactly where you left off. This feature is invaluable for interrupted workflows or multi-day projects.

To review changes made during a session, use /diff. This command displays a clear overview of recent modifications, helping you validate updates before merging them into your codebase. It’s an essential tool for maintaining code integrity and tracking AI-assisted edits.

Navigating projects and managing permissions

Copilot CLI isn’t limited to a single repository. To work across projects, type /cwd to change your working directory. This scopes Copilot’s attention to a specific part of your codebase, enabling efficient multitasking across repositories without losing focus.

Permissions are another critical aspect of secure coding. If you’ve granted Copilot access to edit files in one repository but want to revoke those permissions before switching contexts, /reset-allowed-tools clears all previously approved actions. This ensures you maintain granular control over where and how Copilot operates.

Building a more deliberate workflow

Slash commands aren’t just shortcuts—they’re the foundation of a more intentional coding process. As you integrate them into your workflow, you’ll notice:

• Reduced context switching between tools.
• Faster transitions between tasks.
• Greater transparency into AI-assisted changes.
• Improved control over resource usage and permissions.

The best way to discover their full potential? Open your terminal, type /, and start exploring. Each command you learn adds another layer of efficiency to your development process. Whether you’re fine-tuning a model for a specific task or inspecting changes before deployment, slash commands put you in the driver’s seat.

Happy coding, and may your terminal always be one slash command away from brilliance.