How to Get Started With the GitHub Copilot CLI

Install Copilot CLI

The most portable way to install Copilot CLI is from a terminal. On Linux and macOS, run the official install script, which downloads a prebuilt binary and drops it under ~/.local/bin. On Windows, use WinGet, which downloads the binary and adds copilot.exe to your PATH automatically:

• Windows
• Linux + macOS

PS> winget install GitHub.Copilot

$ curl -fsSL https://gh.io/copilot-install | bash

$ # Or with wget if curl isn't available:
$ wget -qO- https://gh.io/copilot-install | bash

During the installation, the script may ask if you want to add Copilot CLI to your PATH. If you say yes, then it adds the install location to your shell profile so you can run copilot from any terminal window.

If you’d rather use a package manager, Copilot CLI is also distributed through npm and Homebrew on macOS and Linux. Note that the npm method requires Node.js 22 or later:

$ # With npm
$ npm install -g @github/copilot

$ # With Homebrew
$ brew install github/copilot/copilot-cli

GitHub also publishes a Windows installer and source bundles for macOS and Linux on the Copilot CLI releases page. Use those if you need to pin a specific version or if your environment blocks the install commands above.

Once the installation finishes, close and reopen your terminal so the new copilot command is picked up. Then verify that it works:

$ copilot --version
1.0.54
Run 'copilot update' to check for updates.

If you see a version number, then the installation worked, and copilot is ready to use. If you get a command not found or similar error instead, then check the official installation guide for troubleshooting steps.

The next step is to sign in to GitHub so Copilot can reach the AI models and repositories tied to your account.

Authenticate With GitHub

Most of your work with Copilot CLI happens inside an interactive session where you have a conversation with the agent. To get started, run copilot with no arguments from the directory you want to work in:

$ copilot

You’ll be asked if you trust the files in the current directory. If you say yes, then you’ll land at the tool’s main UI. At the bottom of the window, you’ll find a text input box ready for you to start talking to the agent in natural language.

However, you first need to sign in with the /login command:

❯ /login

You’ll be asked whether you want to use GitHub.com or GitHub Enterprise. Choose GitHub.com and press Enter. Copilot will generate a code and provide a login URL. Open the URL in your browser, and the CLI will walk you through the GitHub OAuth flow.

After you authorize the app on your target account, the terminal session is authenticated and ready to go.

To confirm everything is wired up, ask Copilot a quick question:

❯ What version of Copilot CLI are you?
I'm GitHub Copilot CLI v1.0.54.

The agent answers directly from its session context. If you get a version number back, then you’re all set. You can run the /exit command to leave Copilot CLI and return to your shell.

Most of the time, you’ll use Copilot CLI in an interactive session like the one above. However, it’s also possible to run one-shot prompts directly from the command line.

Use One-Shot Prompts

You don’t always need an interactive session to use the copilot command. For quick questions or scriptable tasks, pass your prompt directly with the -p option:

$ copilot -p "Define Python in one sentence."
Python is a high-level, interpreted programming language known for its
readable syntax and versatility.


Changes   +0 -0
Requests  0.33 Premium (13s)
Tokens    ↑ 14.8k • ↓ 43 • 0 (cached) • 20 (reasoning)

This one-shot style is great for quick lookups or when you want to integrate Copilot into a shell script. The output includes the agent’s response, a summary of any file changes, stats about the requests, and a token usage breakdown.

Explore Useful Slash Commands

Run copilot again to start a new session. Inside the UI, you’ll have access to slash commands that allow you to control the session itself and your current project. If you run /help, then you’ll get the full list of slash commands and other useful information, including keyboard shortcuts.

The table below summarizes some of the most useful slash commands to get you started:

In short, slash commands give you a quick way to steer a session from the keyboard. You’ll put several of them, like /init, /diff, and /model, to work in the upcoming sections.

Navigate the CLI

A handful of keyboard shortcuts can ensure you have a fluid interaction while working on your Python projects with Copilot CLI.

Here’s a quick reference to some of the handiest ones:

The @ and # mentions boost your productivity by giving you a quick way to add files, issues, and pull requests as context in your interactive prompts. For example, typing @script.py pulls the content of that file into the agent’s context. Similarly, something like #42 brings the issue or pull request with that number into the conversation.

GitHub draws issue and pull request numbers from the same per-repository sequence, so each #N refers to exactly one item, whether it’s an issue or a pull request.

Explore Your Codebase With Copilot CLI

With a fresh session running inside the project’s folder, ask Copilot to give you a summary of the codebase. First, run the /model command and select the Auto option, which lets Copilot choose a suitable model for you. Then, run the following prompt:

❯ Explore this project and tell me what it does.

The agent will analyze the files in the project, extract relevant information, and produce a concise summary. Click the Show/Hide toggle to see a sample response:

The output above gives you a short summary of the tic-tac-toe game and its main features. For tasks like this, Copilot’s main agent may delegate the work to a specialized subagent, which reads key files, walks the directory tree, and returns a focused summary without flooding the main agent’s context window with irrelevant information.

Delegation tends to kick in on bigger or parallelizable tasks. For a small project like this one, the main agent often handles the exploration directly. You’ll meet the full lineup of built-in subagents in a moment.

Understand Agent Modes

Beyond the agent itself, Copilot CLI exposes modes that control how the main agent behaves. Copilot CLI has three modes:

1. Standard: The default ask-and-execute mode for general conversation and direct code generation.
2. Plan: A read-only mode that confines the agent to producing and refining an implementation plan, with no file edits, command runs, or other side effects.
3. Autopilot: A mode that allows Copilot to work autonomously, performing multiple steps to complete a goal on your behalf.

You switch modes by pressing Shift+Tab. The current mode is shown in the status bar at the bottom of the screen, so you can tell at a glance where you are. Note that the default mode, Standard, doesn’t display its name in the status bar. You’ll put Plan and Autopilot to work shortly, in the Plan Before You Act section.

Initialize the Agent Instructions

Because this is the first time you’re working on this project using GitHub Copilot CLI, you should create customized agent instructions based on the project. You can do this using the /init command. Go ahead and run the following:

❯ /init

Once you press Enter, the agent will scan your project and create the instruction file. By default, this file will live at .github/copilot-instructions.md.

While the agent works on creating this file, you may be asked about some needed actions. Answer as you prefer. At the end of the process, the agent will save the new instruction file. To see what this file might look like, open .github/copilot-instructions.md from the sample project’s root.

Whenever you start a new Copilot session in the project directory, the agent will automatically load this file and add it to its context for working on the project. You can tweak the file as you wish.

The instruction file works as persistent state between agent sessions. Anything you want Copilot to remember about the project, such as coding conventions, architecture, dependency management, or test commands, can live there and will survive across runs. However, keep an eye on the file size. If it grows too large, then the agent may struggle to use it effectively.

Commit the file to source control with the following commands:

$ git add .github/copilot-instructions.md
$ git commit -m "Initialize the agent instructions"

If you’re working with a team on the same project, then you can push this commit to the remote repository. From there, anyone on your team who uses Copilot CLI starts every session with the same baseline context. This keeps the agent’s actions consistent across runs and saves everyone from repeating the same instructions and conventions.

Understand Subagents

You’ve already seen the main agent at work. Behind it, Copilot CLI also has a roster of built-in subagents: internal workers that the main agent calls on for focused tasks. The main ones to know are the following:

• explore: Performs quick codebase analysis so you can ask questions about your code without adding to the main context.
• task: Runs commands such as tests and builds, providing a brief summary on success and the full output on failure.
• general-purpose: Mirrors the main agent’s full capabilities to handle complex, multi-step tasks in a separate context, keeping your main conversation focused.
• code-review: Reviews changes with a focus on surfacing only genuine issues, minimizing noise.
• research: Performs deep research across your codebase, related repositories, and the web, producing a detailed report. It’s invoked when you explicitly call the /research slash command.
• rubber-duck: Acts as a constructive critic powered by a different model family. Copilot consults it automatically at key checkpoints, and you can also request a critique directly with prompts like “Rubber duck your plan.”

You won’t invoke these subagents directly most of the time. Copilot picks the right subagent for each request, which keeps your conversation tidy. In the next section, you’ll have Copilot review your code.

Review Your Code and Make Improvements

Now that Copilot has a sense of the project, you can ask it to review the code critically. A quick review is a low-risk way to surface bugs, dead code, or design choices that could be cleaner before you start changing anything yourself.

Try a prompt like the following:

❯ Review the code for bugs, edge cases, and anything that
  could be simplified. Focus on real issues, not style.

Depending on the project size and your prompt, Copilot may delegate this task to the code-review subagent or handle it inside the main agent. Either way, the review scans your code for issues like logic errors, unhandled edge cases, and other concerns, rather than commenting on code formatting. After a brief wait, you’ll get back a list of findings with suggested improvements.

Click the Show/Hide toggle below to see a sample response:

These findings may look compelling. However, you must analyze each one with a critical eye and make your own call. For this example, you can pick one suggestion and ask Copilot to fix it. Say that you want to start with the first issue:

❯ Let's fix the anti-diagonal calculation issue

Copilot will propose a change and ask for your approval before writing to the file. If you accept, then it makes the change. When the change is done, the agent may run a quick test to verify that the issue is resolved.

To see all the changes made so far, run the /diff command:

❯ /diff

You’ll see something like the following:

In this example, the diff shows that the agent has fixed the issue with the anti-diagonal calculation. Diff Mode also lets you add comments to individual lines so the agent can refine the change further. To leave Diff Mode, press Esc.

At this point, you can commit the changes if they look good to you. Note that the /diff command is based on Git’s diff, so being consistent with your commits is important.

As an exercise, you can go over the rest of the issues and get a feel for how Copilot CLI can help you improve your Python project without touching the code yourself. Once you’re done, move on to bigger changes in the following section.

Plan Before You Act

Before you switch to a new task, it’s best practice to clear your conversation with the /new command. The /clear alias also works if that name feels more familiar to you. A fresh context keeps the agent focused and avoids confusion from earlier, irrelevant exchanges.

For big refactors or new features, it’s worth taking some time to build a coherent action plan. You can use the agent for this planning stage. Press Shift+Tab once to switch to Plan mode and then describe what you want to achieve. For example, here’s a prompt to add a score tracker to the game:

❯ Add a score tracker that counts wins for X and O across multiple rounds.

In Plan mode, Copilot doesn’t touch your files. Instead, it analyzes the request, sometimes asks clarifying questions, and produces a structured plan you can review.

For this specific feature, Copilot CLI may ask you some questions before it writes the plan. For example, it may ask whether you want to persist the score across sessions or reset it when the app restarts. It may also ask how you want the score to be displayed in the UI, and so on. Answer the questions according to your preferences.

When the initial plan is ready, Copilot offers a menu of next steps, including the option to continue right into Autopilot mode and start executing the plan.

If the plan looks off, then you can skip the menu and refine it in plain English until it matches your intent. Once you’ve refined it, press Shift+Tab to switch to Standard or Autopilot mode and then ask Copilot to execute the plan.

Click the Show/Hide toggle below to see a sample plan summary for the score tracker feature:

In Autopilot, the agent works through the plan with minimal interruption, checking in less often than in the other modes. You must review the final diff carefully before committing. If something goes wrong, then double-tap Esc to rewind the session to a previous state and try a different approach.

What Autopilot changes is when Copilot checks in with you, not what it’s allowed to do. If a step needs a permission you haven’t granted, like writing files, running shell commands, or reaching a URL, then Autopilot denies it automatically instead of pausing to ask. That can stall the task halfway through. To pre-approve everything for the session, run the /yolo command:

❯ /yolo

The /yolo command is a session-wide permission grant equivalent to /allow-all. Once it’s on, the agent can use any tool, touch any file, and reach any URL without asking. The grant survives /new and /restart, so you only need to enable it once per session.

To check the current state, run /yolo show. To revoke it, run /yolo off. You can also pre-approve everything at launch time by passing the --yolo or --allow-all-tools flags to copilot, which works for both interactive and non-interactive sessions.

Here’s how the new feature looks once implemented:

In a few minutes, you went from an idea to a working feature without writing a line of code yourself. You planned the change in Plan mode, handed execution off to Autopilot, and reviewed the final result. That plan-execute-review workflow is ideal for more involved tasks in Copilot CLI.

To have an overview of how agent modes flow, pick a mode and press Run. You will be asked to make a few choices:

Keep in mind that your role as the human developer in charge is to thoroughly review the plan and the implementation. If you neglect this responsibility, then you may end up with an unreliable, poor-quality, and hard-to-scale codebase.

Give Copilot a Scoped Coding Task

You can also hand the agent a concrete coding task for direct execution. For example, you may want to add type hints to the codebase. Press Shift+Tab to switch to Standard mode and then run a prompt like the following:

❯ Add type hints to all functions and methods in the codebase.

Copilot CLI will make the changes and display a summary of the edits. Again, you can run /diff to inspect the changes in Diff Mode.

Switch Between AI Providers

Copilot CLI gives you access to models from OpenAI and Anthropic, though the exact lineup depends on your Copilot plan. As of this writing, the Pro plan defaults to GPT-5.4 and also exposes other GPT-5 variants, alongside Anthropic’s Claude Sonnet 4.6 and Claude Haiku 4.5. Because the lineup also shifts with CLI releases, run /model to confirm what you have.

To switch to a different model, run /model inside an interactive session and pick from the list:

❯ /model

The initial picker lets you select the model, and a second picker allows you to choose the reasoning effort.

The reasoning effort controls how long the model thinks before it responds. A higher setting pays off on complex problems, while a lower one returns quicker answers for routine tasks. Note that more reasoning also consumes more tokens.

Switching models manually can be handy in two cases: when you need a faster model to push through a long task, or when a complex problem calls for stronger reasoning. If you’d rather not pick manually, then select the Auto option. That option lets Copilot choose the best model for each request based on the task and current system load, which can lead to faster responses, better performance, and lower token usage.

If one provider is having an outage, then you can swap to the other without restarting the session. Your conversation history follows you to the new model.

Run a Fleet of Agents

Copilot CLI can also run a task across multiple agents with the /fleet command. When you run it, the main agent analyzes your prompt, decides whether the work splits cleanly into independent subtasks, and then acts as an orchestrator that hands those subtasks to subagents.

A natural way to use /fleet is to run it after you build a plan using Plan mode. If the finished plan has multiple independent elements, then Copilot will offer an Accept plan and build on autopilot + /fleet option. Selecting it kicks off Autopilot mode with /fleet, allowing the subtasks to run in parallel and potentially saving you some development time.

Work Directly With GitHub Issues and Pull Requests

Copilot CLI integrates tightly with GitHub.com. Because the CLI authenticates against your GitHub account, it has native access to your repositories, issues, and pull requests. For example, you can ask Copilot CLI to fix an issue by its number:

❯ Fix issue #42

Copilot reads the issue, reviews the relevant files, and edits them in your working directory. When you’re ready to share the work, the /pr create command can open a pull request.

You can also use the /pr command with the following subcommands:

For longer-running work, you can hand a task off to GitHub’s cloud-based coding agent with the /delegate command.

Here’s an example of how you’d use /delegate to split the tic-tac-toe code into separate modules. Note that you can’t run this command on the sample project as is. If you want the command to work, then you’d have to push the project to a GitHub repository first:

❯ /delegate Split the tic-tac-toe code into separate modules
  for game logic and the Tkinter UI.

The delegated task will run on GitHub’s cloud infrastructure. The coding agent commits changes to a dedicated branch and opens a draft pull request right away, then works in the background and requests review when it’s done. This frees your local terminal for other work.

Reuse Instructions and Skills Across AI Tools

If you’ve used Claude Code or other coding agents before, then you’ve probably built up a collection of repo-level instruction files. Copilot CLI respects the same conventions, so you can drop in the following files to reuse your existing instructions:

• AGENTS.md for tool-agnostic project rules
• CLAUDE.md for instructions written for Claude
• GEMINI.md for instructions written for Gemini

For Copilot CLI to pick them up, the CLAUDE.md and GEMINI.md files must live at the root of your repository. The AGENTS.md file is more flexible. Copilot CLI looks for it at the repo root, in your current working directory, and in any directory listed in the COPILOT_CUSTOM_INSTRUCTIONS_DIRS environment variable.

Note that Claude Code and Gemini CLI themselves search for their own files across additional locations, so a layout that works for one of them may not match what Copilot CLI expects.

Copilot also supports the open Agent Skills standard, so any skill you’ve saved under .claude/skills/ is portable to Copilot CLI without changes. That portability lowers the cost of trying Copilot on an existing project. Bring your instructions, keep your skills, and switch tools when it suits you.