Slash Commands in Depth

This guide explains GitHub Copilot slash commands—how to use them in editors like Visual Studio and Visual Studio Code, when Visual Studio provides extra benefits, and practical examples for documentation, explanations, fixes, tests, and project scaffolding.

If you use a licensed edition of Visual Studio (for example, Professional or Enterprise), Copilot access may be included with your Visual Studio subscription. Signing in with a paid GitHub Copilot account inside Visual Studio applies your Copilot subscription limits and features to the IDE. Check your Visual Studio account settings for entitlement details.

Core slash commands (quick reference)

These core slash commands are the most frequently used for day-to-day development tasks such as generating documentation, explaining code, proposing fixes, and starting fresh conversations.

Command	Purpose
`/doc`	Inserts documentation comments appropriate to the language and cursor location (PEP 8–friendly docstrings for Python, XML/Swagger-style comments for C#, etc.).
`/exp`	Starts a new conversation thread with fresh context in Copilot Chat.
`/explain`	Produces a human-readable explanation for selected code or inserts summary comments.
`/fix`	Proposes fixes for problems, typos, or logic errors in the selected code.

A slide titled "Available Slash Commands" showing four labeled boxes: /doc, /exp, /explain, and /fix. Each box gives a brief description of the command (insert docs, start a new thread, explain selected code, and propose fixes).

Other useful slash commands

These additional commands extend Copilot’s capabilities for tests, optimization, scaffolding, and assistance. Use them to speed up repetitive or broader tasks.

Command	Use case / Notes
`/fix-test-failure`	Inspects failing tests and proposes targeted fixes for failures.
`/generate`	Generates code snippets, classes, or skeletons from a prompt (e.g., `/generate create a DB class`).
`/help`	Shows quick reference and usage tips for GitHub Copilot.
`/optimize`	Suggests performance or code-size optimizations for the selected code.
`/tests`	Generates unit tests for the selected code with multiple cases and edge conditions.
`/clear`	Starts a new chat session (clears current context).
`/new`	Scaffolds a new project (examples: `Flask`, `React`, `Vue`, `Blazor`).

Example quick reference (copy/paste into chat if helpful):

/fix-test-failure
/generate
/help
/optimize
/tests
/clear
/new

How to invoke a slash command

You can open and trigger slash commands in several convenient ways:

Type a forward slash / directly in the GitHub Copilot Chat message box.
Click the Slash button in the Copilot Chat UI.
Use inline chat tied to your editor (for example, press Alt + / in many editor setups, or right‑click and select “Ask Copilot” from the context menu).

An infographic titled "Accessing Slash Commands" showing three colorful icons and brief steps: "Type a slash", "Click the Slash button", and "Use inline chat" to open Copilot chat commands.

Why slash commands are convenient

Dedicated Chat Window: Use the fuller chat UI to keep history, thread related prompts, and manage long conversations.
Inline Chat Dialog: Keep context near the code with inline prompts—ideal for quick, localized edits or explanations.
Continuous Workflow: Request documentation, fixes, tests, optimizations, or even scaffold projects without leaving your editor.

A dark-themed slide titled "Seamless Integration" listing three numbered features — Main Chat Window, Inline Chat Dialog, and Continuous Workflow — each with a short description and icon. A small "© Copyright KodeKloud" appears in the bottom-left.

After signing in to Visual Studio with a qualifying account, Copilot surfaces sample actions such as “Summarize my code”, “Write unit tests”, “Fix my code”, and “Explain programming concepts.” These UI shortcuts insert the corresponding slash commands on your behalf and speed up common workflows.

A Visual Studio IDE window showing the "What's New" pane and a GitHub Copilot Chat panel. The Copilot pane lists sample prompts like "Summarize my code" and "Write unit tests."

Examples

Below are practical examples showing where to use slash commands for documentation, components, explanations, and tests. Program documentation example

Open a code file (for example, Program.cs) and type /doc. Copilot inserts language-appropriate documentation comments for symbols near the cursor or for selected code.

Example Program.cs (illustrative):

using KodeKloudDemo.Client.Pages;
using KodeKloudDemo.Components;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddRazorComponents()
    .AddInteractiveWebAssemblyComponents();

var app = builder.Build();

if (app.Environment.IsDevelopment())
{
    app.UseWebAssemblyDebugging();
}
else
{
    app.UseExceptionHandler("/Error", createScopeForErrors: true);
    // The default HSTS value is 30 days. You may want to change this for production scenarios.
    app.UseHsts();
}

app.UseHttpsRedirection();

app.UseStaticFiles();
app.UseAntiforgery();

app.MapRazorComponents<App>()
    .AddInteractiveWebAssemblyRenderMode()
    .AddAdditionalAssemblies(typeof(KodeKloudDemo.Client._Imports).Assembly);

app.Run();

Component example (Counter.razor)

Select the component code and run /doc or /explain to generate component-level comments and method summaries.

@page "/counter"
@using Microsoft.AspNetCore.Components

<h3>Counter</h3>

<p>Current count: @currentCount</p>

<button class="btn btn-primary" @onclick="IncrementCount">Click me</button>

@code {
    /// <summary>
    /// The current count value.
    /// </summary>
    private int currentCount = 0;

    /// <summary>
    /// Increments the current count value by one.
    /// </summary>
    private void IncrementCount()
    {
        currentCount++;
    }
}

Explanation and tests

Highlight code and run /explain to produce readable explanations or XML summary comments. For example, selecting middleware calls might yield:

/// <summary>
/// Enforces HTTPS redirection for all HTTP requests.
/// </summary>
app.UseHttpsRedirection();

/// <summary>
/// Enables serving static files from the web root.
/// </summary>
app.UseStaticFiles();

/// <summary>
/// Enables Anti‑Forgery protection.
/// </summary>
app.UseAntiforgery();

/// <summary>
/// Maps Razor components and adds assemblies required for interactive WebAssembly rendering.
/// </summary>
app.MapRazorComponents<App>()
    .AddInteractiveWebAssemblyRenderMode()
    .AddAdditionalAssemblies(typeof(KodeKloudDemo.Client._Imports).Assembly);

/// <summary>
/// Runs the application and starts listening for incoming requests.
/// </summary>
app.Run();

Use /tests on a method or class to have Copilot scaffold a test file with multiple cases and edge scenarios. If a CI run surfaces failing tests, /fix-test-failure inspects failures and suggests code-level fixes.

Closing notes and best practices

Slash commands are available in both Visual Studio and Visual Studio Code. They accelerate documentation, fixes, optimizations, test generation, and project scaffolding seamlessly within your editor.
Familiarize yourself with the most common commands — they reduce context switching and speed daily development tasks.
Use inline chat for quick, context-sensitive requests and the main chat window for longer or multi-step conversations.

Tip: Use the inline chat for quick context-sensitive requests and the main chat window when you need a longer conversation or to manage multiple related prompts.

Links and references

GitHub Copilot Chat docs: https://docs.github.com/en/copilot/copilot-chat
Visual Studio: https://visualstudio.microsoft.com/
Visual Studio Code: https://code.visualstudio.com/
Flask: https://flask.palletsprojects.com/
React: https://reactjs.org/
Vue: https://vuejs.org/
Blazor: https://dotnet.microsoft.com/apps/aspnet/web-apps/blazor

Introduction

GitHub Copilot Basics

Prompt Engineering with Copilot

Advanced Features

Management of GitHub Copilot

Using Copilot Efficiently

Slash Commands in Depth

Core slash commands (quick reference)

Other useful slash commands

How to invoke a slash command

Why slash commands are convenient

Examples

Closing notes and best practices

Links and references

Watch Video

​Core slash commands (quick reference)

​Other useful slash commands

​How to invoke a slash command

​Why slash commands are convenient

​Demo walkthrough (sign-in and examples)

​Examples

​Closing notes and best practices

​Links and references

Watch Video

Core slash commands (quick reference)

Other useful slash commands

How to invoke a slash command

Why slash commands are convenient

Demo walkthrough (sign-in and examples)

Examples

Closing notes and best practices

Links and references