50 GitHub Copilot Commands, Actions & Workflows

Most “50 Copilot commands” articles are padded with natural-language prompts presented as if they were syntax. That is not a stylistic complaint — it actively misleads people, who then type a sentence expecting a command and conclude the feature is broken.

Every entry below carries a label saying exactly what it is:

Official command — documented syntax you type literally in chat.
CLI command — documented Copilot CLI syntax you type literally.
Prompt — natural language. Nothing in it is a reserved word.
Workflow — a sequence of steps, not a single instruction.

Key takeaways

Chat slash commands differ by editor. Type / in your own chat box for the authoritative list.
Chat variables (#) control context explicitly; chat participants (@) scope a question to a domain.
Copilot CLI has by far the largest command surface, including plan, review and permission modes.
A prompt is not syntax. Nothing in a prompt is reserved, and nothing is guaranteed.
Where a command is destructive or grants permissions, that is stated in its limitations.

Why the distinction matters

It is worth being concrete about what goes wrong when the four categories get blurred, because the failure is not theoretical.

A command is syntax. /explain is a reserved token the client recognises before your text reaches a model. It behaves consistently, it is documented, and it either exists in your environment or it does not.

A prompt is text. “Explain this function and identify edge cases” has no reserved words. It works because it is specific about what it wants, not because any part of it is special. Change the wording and it still works; type it in a terminal and nothing happens.

The confusion runs in both directions. People type a prompt expecting command behaviour and conclude Copilot is broken when it does not fire. And people transcribe a “command” from an article, get nothing, and assume their installation is wrong — when the string was never a command in the first place.

There is a third failure worth naming: assuming a command exists everywhere. /optimize is real, but only in Visual Studio. /simplify is real, but only in Xcode. An article listing them together without saying where they work will send you looking for a feature your editor does not have.

Availability at a glance

Surface	What you get
VS Code chat	The widest slash command set, plus chat variables (`#`) and participants (`@`)
Visual Studio chat	A different slash command set, and file references instead of chat variables
JetBrains chat	Core commands, plus CLI-specific commands during a CLI session
Xcode chat	A small, focused set centred on the current selection
GitHub.com chat	Conversation management commands, plus `@` mentions and MCP skills
Copilot CLI	By far the largest surface: shell commands, slash commands and options

Notice that the concept is consistent everywhere — commands for common operations, a syntax for supplying context — while the specific tokens are not. Learning the concepts transfers; memorising a token list does not.

Chat slash commands in IDEs

Type / in a chat prompt box, followed by the command name.

Entry 1: /explain

Official command

Explains how the code in your active editor works.

/explain

Category: Comprehension
Environment: VS Code, Visual Studio, JetBrains, Xcode
When to use: Landing in unfamiliar code, or verifying that a function does what its name claims.
Limitations: Explains what the code does, not why it was written that way. It has no access to the decision that produced it.

Entry 2: /fix

Official command

Proposes a fix for problems in the selected code.

/fix

Category: Debugging
Environment: VS Code, Visual Studio, JetBrains, Xcode
When to use: A specific error or warning is visible and the selection is small enough to review.
Limitations: Fixes the symptom it can see. If the root cause is elsewhere, it will produce a plausible local patch.

Entry 3: /tests

Official command

Generates unit tests for the selected code.

/tests

Category: Testing
Environment: VS Code, Visual Studio, JetBrains, Xcode
When to use: Adding coverage to existing code whose contract is already settled.
Limitations: Generated tests often assert current behaviour rather than intended behaviour, which will cheerfully lock in a bug.

Entry 4: /clear

Official command

Starts a new chat session, clearing the conversation.

/clear

Category: Session
Environment: VS Code, GitHub.com
When to use: Switching problems. Stale context is the most common cause of confusing answers.
Limitations: The context is gone. Anything you established earlier must be restated.

Entry 5: /new

Official command

Creates a new project in VS Code; starts a new conversation on GitHub.com.

/new

Category: Scaffolding
Environment: VS Code, GitHub.com
When to use: Scaffolding a project structure from a description rather than from a template.
Limitations: Two different behaviours behind one name depending on where you are. Generated scaffolding reflects common conventions, not your team's.

Entry 6: /help

Official command

Shows a quick reference for using Copilot.

/help

Category: Reference
Environment: VS Code, Visual Studio, JetBrains
When to use: Checking what is available in the current environment rather than trusting an article.
Limitations: Covers Copilot usage, not your codebase.

Entry 7: /fixTestFailure

Official command

Finds and fixes a failing test.

/fixTestFailure

Category: Testing
Environment: VS Code
When to use: A test is red and the failure output is legible.
Limitations: May make the test pass by changing the test. State explicitly that the test must not be modified if that matters.

Entry 8: /doc

Official command

Adds a documentation comment for the selected symbol.

/doc

Category: Documentation
Environment: Visual Studio, Xcode
When to use: Documenting an API surface where the contract is already clear from the code.
Limitations: Describes what the code does. If the code is wrong, the docstring will faithfully document the wrong behaviour.

Entry 9: /optimize

Official command

Analyses and improves the running time of the selected code.

/optimize

Category: Performance
Environment: Visual Studio
When to use: A specific hot path has been identified by profiling.
Limitations: Optimises what it can see. It cannot measure, so it cannot know whether this is the bottleneck.

Entry 10: /simplify

Official command

Simplifies the current code selection.

/simplify

Category: Refactoring
Environment: Xcode
When to use: A function has grown convoluted and you want a second opinion on its shape.
Limitations: Simplicity is a judgement call. Verify that behaviour is unchanged rather than assuming it.

Entry 11: /compact

Official command

Compresses the current session context to keep a long-running session manageable.

/compact

Category: Session
Environment: JetBrains, Copilot CLI
When to use: A long session is starting to lose earlier detail but you do not want to start over.
Limitations: Compression is lossy by definition. Details judged unimportant are discarded.

Entry 12: /chronicle

Official command

Reviews and analyses your session history. Subcommands include standup, tips, search and improve.

/chronicle standup

Category: Session
Environment: JetBrains, Copilot CLI
When to use: Summarising what you worked on, or looking back through a long session.
Limitations: Covers Copilot session history only, not your Git history or your day.

Chat commands on GitHub.com

Entry 13: /rename

Official command

Renames the current conversation.

/rename

Category: Session
Environment: GitHub.com
When to use: Keeping a set of long-running conversations findable.
Limitations: Cosmetic. Does not change the conversation content.

Entry 14: /delete

Official command

Deletes a conversation.

/delete

Category: Session
Environment: GitHub.com
When to use: Clearing out conversations you no longer need.
Limitations: Destructive and not undoable. Check which conversation is selected first.

Chat context syntax

Slash commands tell Copilot what to do. Context syntax tells it what to look at, and it is the more consequential of the two.

The reason is straightforward: a slash command with the wrong context produces a confident answer about the wrong code. /explain on a file you did not mean to have focused is not a malfunction — it is a correct explanation of something irrelevant. Being explicit about context removes an entire category of confusing results.

Chat variables include specific context in a prompt. Type # in the prompt box. These are documented for VS Code.

Entry 15: #file

Official command

Includes the current file's content in the prompt.

Explain the caching strategy in #file

Category: Context
Environment: VS Code chat
When to use: The answer depends on the whole file rather than the selection.
Limitations: A large file consumes a lot of the context window, leaving less room for the answer.

Entry 16: #selection

Official command

Includes the currently selected text in the prompt.

Rewrite #selection to use a guard clause instead of nesting

Category: Context
Environment: VS Code chat
When to use: Asking about one specific block rather than the surrounding file.
Limitations: A selection torn from its context can be genuinely ambiguous.

Entry 17: #project

Official command

Includes project context in the prompt.

Where is authentication handled in #project

Category: Context
Environment: VS Code chat
When to use: Questions that span the project rather than sitting in one file.
Limitations: Broad context is not the same as complete context. It still cannot see everything.

Entry 18: #function

Official command

Includes the current function or method in the prompt.

What edge cases does #function miss

Category: Context
Environment: VS Code chat
When to use: Focused questions about one function without selecting it manually.
Limitations: Excludes helpers the function calls, which is often where the answer actually is.

Entry 19: #class, #block, #line, #path, #sym, #comment

Official command

Include the current class, block, line, file path, symbol or comment respectively.

Explain how #class relates to #sym

Category: Context
Environment: VS Code chat
When to use: Narrowing context to exactly the scope your question concerns.
Limitations: Each includes only its own scope. Combining several is often better than picking one.

Entry 20: #MyFile.cs and #solution

Official command

References a specific file, specific lines within a file, or the whole solution.

Explain this function #MyFile.cs: 66-72

Category: Context
Environment: Visual Studio chat
When to use: Visual Studio, where file references replace the chat variable syntax used in VS Code.
Limitations: Visual Studio syntax. It does not work in VS Code.

Entry 21: @github

Official command

Scopes the prompt so Copilot can use GitHub-specific skills.

@github What changed in the last release

Category: Context
Environment: VS Code chat
When to use: Questions about repositories, issues and pull requests rather than local code.
Limitations: Reaches GitHub, not your local working tree.

Entry 22: @terminal

Official command

Gives Copilot context about the VS Code terminal shell and its contents.

@terminal Why did that command fail

Category: Context
Environment: VS Code chat
When to use: A command failed and you do not want to paste the output manually.
Limitations: Sees the terminal, not your shell configuration or environment variables.

Entry 23: @vscode

Official command

Gives Copilot context about VS Code commands and features.

@vscode How do I change the default formatter for Python

Category: Context
Environment: VS Code chat
When to use: Configuring the editor, or finding a setting you cannot remember the name of.
Limitations: Answers about VS Code, not about your code.

Entry 24: @azure

Official command

Provides context about Azure services and how to use, deploy and manage them.

@azure How do I deploy this container app

Category: Context
Environment: VS Code chat
When to use: Working with Azure resources from the editor.
Limitations: Currently in public preview and subject to change.

Copilot CLI — command line

Copilot CLI has a considerably larger command surface than any chat interface, for a structural reason: it is an agent with a permission model, session management and its own configuration, so it needs commands for all three.

The commands below split into three groups. Shell commands (copilot login, copilot init) are typed at your prompt. Slash commands (/plan, /review) are typed inside a running session. Options (--model, --allow-all-tools) modify how a session starts. Mixing them up is the most common CLI mistake — /plan at a shell prompt does nothing, and --model inside a session is just text.

Run these from your shell.

Entry 25: copilot

CLI command

Launches the interactive Copilot CLI interface.

copilot

Category: CLI
Environment: Terminal
When to use: Starting an agent session in the terminal.
Limitations: Interactive. For scripting, use the -p option instead.

Entry 26: copilot login

CLI command

Authenticates with Copilot via OAuth. Supports --host, --web-flow and --device-code.

copilot login --device-code

Category: CLI
Environment: Terminal
When to use: First run, after switching accounts, or when authentication expires.
Limitations: Classic personal access tokens beginning ghp_ are not supported. Fine-grained tokens need the Copilot Requests permission.

Entry 27: copilot init

CLI command

Initialises Copilot custom instructions for the current repository.

copilot init

Category: Customization
Environment: Terminal
When to use: Setting up a repository so every future session inherits your conventions.
Limitations: Generates a starting point. The conventions that matter still have to be written by someone who knows them.

Entry 28: copilot -p

CLI command

Executes a prompt programmatically and exits. Combine with --allow-all-tools for non-interactive use.

copilot -p "Summarise the changes on this branch" --allow-all-tools

Category: Automation
Environment: Terminal, CI
When to use: Scripting, CI jobs, or anything where nobody is present to answer prompts.
Limitations: Requires --allow-all-tools, which disables the permission prompts. Only use it where the working directory is disposable.

Entry 29: copilot --model

CLI command

Selects the model for the session. Pass auto to let Copilot choose.

copilot --model claude-sonnet-4.6

Category: Models
Environment: Terminal
When to use: Matching model cost to task difficulty. Mechanical work does not need a premium reasoning model.
Limitations: Available models depend on your plan. Different models consume AI credits at different rates.

Entry 30: copilot --worktree

CLI command

Creates or reuses an isolated Git worktree and starts the session inside it.

copilot --worktree

Category: Git
Environment: Terminal
When to use: Letting an agent work without touching your current working tree.
Limitations: Creates directories under the repository. Clean them up when finished.

Entry 31: copilot --resume

CLI command

Resumes a previous session by ID, ID prefix or name.

copilot --resume

Category: Sessions
Environment: Terminal
When to use: Picking up where you left off without re-establishing context.
Limitations: Resumed context counts toward the context window, so a long session may need compacting.

Entry 32: copilot update

CLI command

Downloads and installs the latest Copilot CLI version.

copilot update

Category: Maintenance
Environment: Terminal
When to use: When a documented feature appears to be missing. Version drift is the usual cause.
Limitations: Auto-update is on by default unless disabled with --no-auto-update.

Copilot CLI — slash commands

Type these inside an interactive session.

Entry 33: /plan

CLI command

Creates an implementation plan before writing any code.

/plan Add rate limiting to the public API endpoints

Category: Agents
Environment: Copilot CLI session
When to use: Before any non-trivial change. Reviewing a plan is far cheaper than reviewing a wrong diff.
Limitations: A plan is a proposal. It is not a commitment, and the implementation can still diverge.

Entry 34: /review

CLI command

Runs the code review agent to analyse your changes.

/review

Category: Review
Environment: Copilot CLI session
When to use: Before opening a pull request, so obvious findings are gone before a human looks.
Limitations: Reviews the diff, not the system. It cannot tell you the change is wrong given something happening elsewhere.

Entry 35: /security-review

CLI command

Runs a focused security review of local changes and returns prioritised findings with remediation suggestions.

/security-review

Category: Security
Environment: Copilot CLI session
When to use: Any change touching authentication, authorisation, input handling or deserialisation.
Limitations: Not a substitute for a security audit or a real scanner. Absence of findings is not evidence of safety.

Entry 36: /permissions

CLI command

Switches between permission modes — default, assisted and allow-all — or shows the current mode.

/permissions show

Category: Security
Environment: Copilot CLI session
When to use: Deliberately widening or narrowing what the agent may do without asking.
Limitations: allow-all removes the approval prompts entirely. Enterprise policy can disable that mode.

Entry 37: /model

CLI command

Selects the model mid-session, or chooses Auto. Scopes include --session, --global, --repo and --local.

/model gpt-5.4

Category: Models
Environment: Copilot CLI session
When to use: Switching to a heavier model for one hard step, then back down.
Limitations: Model availability depends on your plan, and switching mid-session does not re-run earlier steps.

Entry 38: /undo

CLI command

Opens the rewind picker to roll the session back to an earlier user turn.

/undo

Category: Sessions
Environment: Copilot CLI session
When to use: An agent went in a direction you did not want and you would rather rewind than argue.
Limitations: Rolls back the session. Read the options carefully — rolling back the conversation and rolling back files are different choices.

Entry 39: /context

CLI command

Shows context window token usage and a visualisation of what is consuming it.

/context

Category: Sessions
Environment: Copilot CLI session
When to use: A long session is degrading and you want to know whether the window is the cause.
Limitations: Shows usage, does not reduce it. Use /compact for that.

Entry 40: /diff

CLI command

Reviews changes in the current directory, switching to a branch diff when the working tree is clean.

/diff

Category: Review
Environment: Copilot CLI session
When to use: Checking what an agent actually changed before committing anything.
Limitations: Marked experimental in GitHub's reference.

Entry 41: /pr

CLI command

Manages pull requests for the current branch. Subcommands include view, create, fix, auto and automerge.

/pr create

Category: Git
Environment: Copilot CLI session
When to use: Taking a finished branch through to a pull request without leaving the session.
Limitations: automerge drives a pull request to merge. Understand what that will do in your repository before using it.

Entry 42: /delegate

CLI command

Delegates changes to a remote repository with an AI-generated pull request.

/delegate Add pagination to the orders endpoint

Category: Agents
Environment: Copilot CLI session
When to use: Handing off well-specified work rather than doing it locally.
Limitations: Delegated work is reviewed at the end, not steered along the way.

Entry 43: /sandbox

CLI command

Manages OS-level sandboxing that restricts filesystem and network access for shell commands, MCP and LSP servers, and built-in tools.

/sandbox status

Category: Security
Environment: Copilot CLI session
When to use: Running an agent with broader permissions but a hard boundary around what it can reach.
Limitations: An enterprise-managed policy can force sandboxing on as a floor that cannot be lifted locally.

Entry 44: /mcp

CLI command

Manages MCP server configuration — list, show, add, edit, delete, disable, enable, auth, reload and search.

/mcp list

Category: MCP
Environment: Copilot CLI session
When to use: Connecting Copilot to external tools and data sources.
Limitations: An MCP server is code you are granting access to your environment. Treat adding one like adding a dependency.

Entry 45: /instructions

CLI command

Views and toggles the custom instruction files currently in effect.

/instructions

Category: Customization
Environment: Copilot CLI session
When to use: Diagnosing why an agent is ignoring a convention you thought you had configured.
Limitations: Shows what is loaded. It does not tell you how heavily any of it was weighted.

Entry 46: /usage

CLI command

Displays session usage metrics and statistics, including per-model token totals.

/usage

Category: Billing
Environment: Copilot CLI session
When to use: Working out what is consuming your AI credits. Agent sessions dwarf completions.
Limitations: Session-scoped. Full account usage lives in your GitHub billing settings.

Prompts, not commands

These are natural language. Nothing in them is reserved syntax, and nothing is guaranteed — they work because they are specific, not because they are special.

Entry 47: Explain and identify edge cases

Prompt

Gets an explanation framed around failure rather than the happy path.

Explain this function, identify edge cases, and write pytest tests
for success, boundary, and failure conditions.

Category: Comprehension
Environment: Any chat surface
When to use: Reviewing unfamiliar code, or your own code before a pull request.
Limitations: Findings are hypotheses, not test results. Verify each one.

Entry 48: Refactor with a stated constraint

Prompt

Requests a refactor while fixing the things that must not change.

Refactor this function to reduce duplication without changing
externally observable behaviour. Keep the public signature, the
exception types, and the log messages exactly as they are.

Category: Refactoring
Environment: Any chat surface
When to use: Any refactor. Without the constraint, helpfulness manifests as unrequested changes.
Limitations: A stated constraint is respected most of the time, not always. Check the diff.

Entry 49: Generate infrastructure with justification

Prompt

Requests configuration alongside the reasoning, so it can be evaluated rather than trusted.

Create a Dockerfile for this FastAPI application. Use a non-root
runtime user and explain each security decision.

Category: DevOps
Environment: Any chat surface
When to use: Dockerfiles, CI workflows, Terraform — anywhere a wrong default fails silently rather than loudly.
Limitations: The explanation is generated too. It is a starting point for your judgement, not a substitute for it.

Workflows

Sequences rather than single instructions.

Entry 50: Plan, implement, review, verify

Workflow

The full loop for a non-trivial change, with a review gate before and after implementation.

1. /plan Add rate limiting to the public API endpoints
2. Review the plan. Correct it before any code is written.
3. Approve implementation, watching terminal approvals as they appear.
4. /review
5. /security-review
6. Run the test suite yourself, in your own terminal.
7. /pr create

Category: Agents
Environment: Copilot CLI or agent mode
When to use: Any change large enough that a wrong direction would be expensive to unwind.
Limitations: Each stage is a draft. The final verification is yours and does not get delegated.

Building a command habit

Fifty entries is a reference, not a curriculum. In practice most developers settle on a small working set and reach for the rest occasionally. Here is a reasonable progression.

Week one — comprehension. Use /explain and the context syntax, nothing else. The goal is to build the reflex of supplying context deliberately rather than hoping the right thing is focused. #file, #selection and #function cover almost everything at this stage.

Week two — the feedback loop. Add /tests and /fix, and start reading what they produce rather than applying it. This is where you calibrate: you learn what Copilot gets right in your codebase and what it consistently gets wrong, which is knowledge no article can give you.

Week three — the CLI. Install it, run copilot init in a repository you know well, and use /plan before /review. Planning before implementing is the single habit that most improves agent output, and the CLI makes it explicit.

Ongoing — permissions and cost. /permissions show and /usage are the two you should check periodically rather than daily. The first tells you what an agent may do without asking; the second tells you what your sessions are costing. Both are easy to leave unexamined until something surprises you.

Common mistakes

Typing a prompt as a command. /refactor this to be faster is not a command in any documented environment. /fix is; the rest of that string is just text following it.

Assuming cross-editor parity. Checked above, worth repeating: the sets genuinely differ, and the differences are not obvious from the names.

Using allow-all to move faster. It works, and it removes the boundary that makes an agent with shell access safe. Reserve it for disposable environments.

Ignoring /plan because it feels like overhead. Reviewing a plan takes a minute. Reviewing a wrong implementation takes considerably longer, and unwinding one takes longer still.

Treating /review or /security-review as sufficient. Both are useful first passes that clear obvious findings before a human looks. Neither is a review, and neither can tell you that a change is wrong given something happening elsewhere in the system.

What is not on this list

Copilot CLI alone documents considerably more slash commands and options than appear here — /fleet, /research, /rubber-duck, /autopilot, /worktree, /skills, /agent, /share, /session, /limits and many more, plus a large set of command-line options.

They are omitted because this is Cluster 1, and the entries above are the ones worth knowing in your first weeks. Copilot CLI gets a full cluster later in the Academy roadmap; for the complete surface, GitHub’s CLI command reference is authoritative and is linked in the sources below.

How to find what is actually available

The single most useful habit on this page:

In chat, type / and read the list. It reflects your editor, version and context.
In Copilot CLI, run /help in a session, or copilot help from the shell.
For options, run copilot help and the topic — billing, config, commands, environment, logging, monitoring, permissions, providers or sandbox.

Any article, including this one, is a snapshot. Your own environment is the authority.

Copilot Chat — using these commands in context.
Keyboard Shortcuts — the bindings that go with them.
Agent Mode — what the agentic commands are driving.
50 Things You Can Do with Copilot — the jobs rather than the syntax.

Sources

Every version-sensitive claim on this page was checked against first-party documentation. Only sources actually used are listed.

Primary sources

GitHub Copilot Chat cheat sheetGitHub Docs · accessed Aug 20, 2026
GitHub Copilot CLI command referenceGitHub Docs · accessed Aug 20, 2026
Keyboard shortcuts for GitHub Copilot in the IDEGitHub Docs · accessed Aug 20, 2026
GitHub Copilot featuresGitHub Docs · accessed Aug 20, 2026

Your progress

GitHub Copilot Fundamentals0 of 13 complete

Saved in this browser only. No account, no server, and nothing leaves your device. Clearing site data resets it.

Was this lesson helpful?

Your answer is stored in this browser and is not sent anywhere.

Key takeaways

Why the distinction matters

Availability at a glance

Chat slash commands in IDEs

Chat commands on GitHub.com

Chat context syntax

Copilot CLI — command line

Copilot CLI — slash commands

Prompts, not commands

Workflows

Building a command habit

Common mistakes

What is not on this list

How to find what is actually available

Related lessons

Sources

Primary sources

Your progress

Was this lesson helpful?

Continue learning