GitHub Copilot CLI went generally available today with full agent mode — and it’s the most significant upgrade to terminal-native AI development since GitHub CLI launched. This guide gets you set up and running productive agent workflows from the shell without touching a browser or IDE.

Prerequisites

  • GitHub account with an active Copilot Individual, Team, or Enterprise subscription
  • Node.js 18+ (for the npm package)
  • GitHub CLI (gh) version 2.40 or later
  • A Unix-like terminal (macOS Terminal, iTerm2, Windows Terminal with WSL, or any Linux terminal)

Step 1: Install the Copilot CLI Extension

Copilot CLI installs as a gh extension. If you have gh installed and authenticated, run:

gh extension install github/gh-copilot

Verify the installation:

gh copilot --version

If you don’t have gh installed yet:

# macOS
brew install gh

# Ubuntu/Debian
sudo apt install gh

# Windows (via Winget)
winget install GitHub.cli

Then authenticate:

gh auth login

Follow the prompts — browser-based OAuth is the fastest path. Once authenticated, install the Copilot extension as above.

Step 2: Configure Your Model

Copilot CLI defaults to GitHub’s standard Copilot model. To use Claude or GPT-5 (available with Copilot Enterprise):

gh copilot config set model claude-3.7-sonnet

Available models:

gh copilot config list-models

For most command-line workflows, the default GitHub Copilot model is sufficient. Switch to Claude if you need stronger reasoning for complex multi-step tasks or code review.

Step 3: Basic Usage — Explain, Suggest, Translate

Before agent mode, get familiar with the three core single-shot commands. These are fast, non-interactive, and safe to use in any context.

Explain a command:

gh copilot explain "awk '{sum += $2} END {print sum}' data.tsv"

Copilot returns a plain-English explanation. Useful when you encounter an unfamiliar command in a script or a colleague’s Makefile.

Suggest a command:

gh copilot suggest "find all Python files modified in the last 7 days and count lines of code"

Copilot returns a command suggestion with a brief explanation. You can copy it directly to your clipboard.

Translate a command across shells:

gh copilot translate "Get-ChildItem -Recurse -Filter *.log | Remove-Item" --to bash

Useful when copying PowerShell commands from documentation and running them in bash.

Step 4: Agent Mode — Planning Multi-Step Tasks

Agent mode is where Copilot CLI becomes genuinely powerful. Start an agent session with:

gh copilot agent

This opens an interactive session with planning capabilities. Unlike the single-shot commands above, agent mode maintains context across multiple steps and can execute commands on your behalf (with confirmation prompts by default).

Your first agent task:

In the agent prompt, describe what you want to accomplish:

> I need to add request rate limiting to the Express API in ./src/server.js. 
  The API currently has no rate limiting. Use express-rate-limit and configure 
  it for 100 requests per 15 minutes per IP.

Copilot will respond with a plan before taking any action:

Here's what I'll do:
1. Check the current express version in package.json
2. Install express-rate-limit as a dependency
3. Add rate limiter middleware to server.js before the route definitions
4. Add configuration for 100 requests/15min per IP
5. Verify the changes look correct

Shall I proceed? [y/n]

Review the plan. If it looks right, confirm with y. If you want to adjust (e.g., different rate limits), say so in natural language before confirming.

Step 5: Agent Execution With Command Confirmation

By default, agent mode uses command confirmation — it shows you each command before running it and waits for your approval. This is the safe default. You can see what it’s about to do before it does it.

Example execution flow:

> Running step 1: Check express version
$ cat package.json | grep '"express"'
→ "express": "^4.21.0"
[auto-continued — read-only command]

> Running step 2: Install express-rate-limit
$ npm install express-rate-limit
[Confirm? y/n]

Read-only commands (cat, grep, ls, git log) auto-continue without prompting. Write commands (npm install, git commit, file writes) always prompt.

To disable confirmation for a session (useful in trusted environments):

gh copilot agent --no-confirm

Never use --no-confirm in a directory with uncommitted important work, or with agents you haven’t already calibrated to your codebase conventions.

Step 6: Code Review From the Terminal

One of the most useful new features in the GA release: code review without leaving the shell.

Review the current branch against main:

gh copilot review

Review a specific PR:

gh copilot review --pr 247

Review a specific diff:

git diff HEAD~1 | gh copilot review --stdin

Copilot returns a structured review with:

  • Summary of changes
  • Issues categorized by severity (blocking, suggestion, nitpick)
  • Inline references to specific lines
  • Suggested fixes in code blocks

To apply a specific suggestion from the review directly:

gh copilot review apply --suggestion 3

This patches the file at the referenced location with Copilot’s proposed change. Review the diff before committing.

Step 7: Custom Agents

For project-specific workflows, define custom agents in .github/agents/:

mkdir -p .github/agents

Create a custom agent definition (test-writer.yml):

name: test-writer
description: "Generate unit tests following this project's testing conventions"
model: claude-3.7-sonnet
system_prompt: |
  You are a test writer for a TypeScript/Express project using Jest and Supertest.
  Always use describe/it blocks, never test(). 
  Follow AAA pattern (Arrange, Act, Assert) with comments.
  For API endpoint tests, use Supertest request objects.
  Never use console.log in tests.
instructions:
  - Read existing tests in __tests__/ for pattern reference before writing new tests
  - Generate tests for both happy path and error conditions
  - Include at least one edge case per function tested

Use the custom agent:

gh copilot agent --agent test-writer
> Write tests for the UserAuthService.createToken() method in src/auth/UserAuthService.ts

Custom agents are stored in your repository and shared with your team — everyone on the project gets the same agent definitions.

Tips for Effective Terminal AI Development

Use agent mode for tasks with 3+ steps. Single-step tasks are faster with direct CLI commands or the single-shot Copilot commands. Agent mode’s overhead pays off when planning saves you from wrong turns.

Commit before agent sessions. Agent mode modifies files. A clean git state lets you git diff clearly and git restore easily if the agent takes an unexpected direction.

Give context via file paths, not file contents. Instead of copying code into the prompt, reference the file: “Update the auth logic in src/auth/UserAuthService.ts” gives the agent a precise target. It reads the file itself.

Chain agent sessions for large features. Break large features into independent components and run a focused agent session for each. Long, multi-objective agent sessions produce less reliable results than focused ones.

The full Copilot CLI documentation is available at docs.github.com/copilot/cli.