GitHub Copilot CLI

Quick Reference

Cheat Sheet

01 / Setup

Getting Started

Installation

Install GitHub Copilot CLI via npm:

npm install -g @github/copilot

Alternatively, install as a GitHub CLI extension:

gh extension install github/gh-copilot
gh copilot

Authentication

Authenticate with your GitHub account:

copilot login

Non-Interactive / CI Authentication

For automated environments, use a Personal Access Token with the "Copilot Requests" permission:

# Set token as environment variable
export GH_TOKEN=your_token_here
# or
export GITHUB_TOKEN=your_token_here

# For credential managers
export GITHUB_ASKPASS=/path/to/executable/that/returns/token

Initial Setup

copilot init           # Initialize configuration
copilot version        # Check installed version
copilot update         # Update to latest version
copilot help           # View available commands

02 / Core Experience

Interactive Mode

Starting a Session

copilot                # Start interactive session (default)
copilot --continue     # Resume most recent session
copilot --resume       # Browse and resume sessions

Slash Commands

Type / during an interactive session to see all available commands. Here is the full reference:

Session Management

Directory & File Access

Code, Models & Agents

Sharing

Keyboard Shortcuts

Plan Mode

Press Shift+Tab to enter plan mode. Copilot will analyze your request, ask clarifying questions, and build a structured implementation plan before writing any code. This is ideal for major refactors or complex features.

03 / Automation

Non-Interactive Mode

Use the -p (or --prompt) flag for single-shot execution, perfect for scripting and CI/CD pipelines.

Basic Usage

copilot -p "your prompt here"
copilot --prompt "your prompt here"

Examples

# Find information
copilot -p "List all open issues assigned to me in OWNER/REPO"

# Code generation
copilot -p "Generate unit tests for main.js"

# Code analysis
copilot -p "Find all TODO comments in src/ directory"

Piping & Chaining

# Pipe input to Copilot
echo "Explain this code" | copilot -p

# Chain with other tools
copilot -p "Run tests" --allow-all-tools

# Export results to file
copilot -p "Analyze code quality" --share > report.md

CI/CD Integration

# Automated quality check in pipeline
copilot -p "Run full test suite and generate coverage report" \
  --allow-all-tools \
  --share-gist \
  --model gpt-5-mini

04 / Models

Model Selection

Choose the right model for your task. Switch at launch with --model or mid-session with /model.

Available Models

Claude (Anthropic)

GPT (OpenAI)

Other available models: gpt-5.2, gpt-5.1-codex, gpt-5.1, gpt-5, gpt-5.1-codex-mini

Google

Model Selection Strategy

05 / Security

Permission System

Copilot CLI uses a layered permission system. By default, each tool execution requires interactive approval. Use flags to grant broader access.

Tool Permissions

# Allow specific tools (glob patterns supported)
--allow-tool "shell(npm run test:*)"
--allow-tool "read"

# Deny specific tools (takes precedence over allow)
--deny-tool "shell"
--deny-tool "write(*.env)"

# Auto-approve all tool executions
--allow-all-tools

Path Permissions

# Allow access to all file paths
--allow-all-paths

# Grant directory access in session
/add-dir /path/to/directory

URL Permissions

# Allow specific URL patterns
--allow-url "https://api.example.com/*"

# Deny URL patterns
--deny-url "https://internal.corp/*"

Convenience Flags

Permission Examples

# Secure code review (read-only, no shell)
copilot -p "Review security in auth module" \
  --allow-tool "read" \
  --deny-tool "shell" \
  --allow-all-paths

# Enterprise-safe automation (specific tools only)
copilot -p "Deploy to staging" \
  --allow-tool "shell(kubectl *)" \
  --allow-tool "shell(docker *)" \
  --deny-url "*" \
  --config-dir /etc/copilot

# Fast prototyping (full trust)
copilot --yolo --model claude-opus-4.6

06 / Extensibility

MCP Integration

Model Context Protocol (MCP) is an industry-standard protocol that allows Copilot CLI to integrate with custom context providers and external tools.

Configuration

MCP servers are configured in ~/.copilot/mcp-config.json:

{
  "mcpServers": {
    "my-server": {
      "command": "npx",
      "args": ["-y", "my-mcp-server"],
      "env": {
        "API_KEY": "your-key"
      }
    }
  }
}

GitHub MCP Server

The built-in GitHub MCP server provides tools for issues, PRs, repositories, and Copilot Spaces:

# Enable all GitHub MCP tools
copilot --enable-all-github-mcp-tools

# Add a specific tool
copilot --add-github-mcp-tool github_search_code

# Add a toolset (e.g., all issue-related tools)
copilot --add-github-mcp-toolset issues

MCP Flags Reference

Custom MCP Servers

Define custom servers at the user level (~/.copilot/mcp-config.json), in organization/enterprise agent profiles, or via the --additional-mcp-config flag.

07 / Continuity

Session Management

Continuing Sessions

# Resume the most recently closed session
copilot --continue

# Browse and pick from local and remote sessions
copilot --resume

# Resume a specific session by ID (in interactive mode)
/resume SESSION-ID

Session Storage

• Local sessions are stored in ~/.copilot/session-state/
• Remote sessions can be loaded for collaboration (since v0.0.376, January 2026)

Context Management

Automatic compression: When approaching 95% of the token limit, Copilot automatically compresses history in the background without interruption. This enables virtually infinite sessions.

# Manually compress context anytime
/compact

# Reset context completely
/clear

Sharing Sessions

Export to Markdown

# In interactive mode
/share

# As a CLI flag (exports on completion)
copilot -p "..." --share

Export to GitHub Gist

# In interactive mode (prompts for visibility, description, filename)
/share gist

# As a CLI flag
copilot -p "..." --share-gist

Exports include timestamp, model used, token usage, and full conversation history with formatting preserved.

08 / Customization

Configuration

Config Directory Structure

Custom Instructions

Copilot CLI loads instructions from multiple sources, in order of priority:

User-Level

$HOME/.copilot/copilot-instructions.md

Repository-Level

.github/copilot-instructions.md
.github/instructions/**/*.instructions.md
CLAUDE.md                   # Claude-specific
GEMINI.md                   # Gemini-specific
AGENTS.md                   # Agent definitions

Custom Directories

# Set via environment variable (comma-separated)
export COPILOT_CUSTOM_INSTRUCTIONS_DIRS="/path/to/dir1,/path/to/dir2"

Repository-level instructions take precedence and enforce team conventions. Instructions are cached; restart CLI or use /resume after editing.

Custom Agents

Create specialized agents using Markdown files with YAML frontmatter:

# ~/.copilot/agents/test-agent.md
---
name: test-agent
description: Runs tests and analyzes failures
tools:
  - shell
  - read
---

Always run tests with verbose output.
If failures occur, analyze stack traces and suggest fixes.

Agent Locations

• ~/.copilot/agents/ — User-level agents
• .github/agents/ — Repository-level agents
• {org}/.github/agents/ — Organization-level agents

Built-in Agents (2026)

• Explore — Fast codebase analysis without cluttering main context
• Task — Run commands like tests and builds

# Invoke a custom agent in interactive mode
/agent my-agent

# Invoke the explore agent
/agent explore

Plugin System

Plugins extend Copilot CLI with custom agents, MCP servers, skills, and LSP configurations.

# Manage plugins
copilot plugin [command]

Plugin sources include GitHub repositories, direct URLs, and local file paths. The copilot-plugins repository serves as a centralized registry.

Disabling Custom Instructions

# Ignore all custom instruction files for this session
copilot --no-custom-instructions

09 / Reference

CLI Flags Reference

Core Commands

Operating Modes

Model & Session

Permission Flags

MCP Configuration

Directory, Context & Misc

10 / Mastery

Pro Tips

Effective Usage Patterns

1. Break Down Complex Tasks

Be specific about requirements and provide examples:

copilot -p "Refactor AuthService to use dependency injection. \
Current implementation uses singletons. Preserve existing test coverage."

2. Use Plan Mode for Major Changes

Press Shift+Tab before implementing major features. Copilot asks clarifying questions, builds a structured plan, and you approve before execution.

3. Switch Models Based on Task Complexity

# Start fast with sonnet
copilot --model claude-sonnet-4.5

# Switch mid-session when hitting complex decisions
/model
# Select claude-opus-4.6

# Back to fast model for iterations
/model
# Select gpt-5-mini

4. Leverage Custom Agents

Create specialized agents for recurring workflows:

# ~/.copilot/agents/security-review.md
---
name: security-review
description: Reviews code for security vulnerabilities
tools:
  - read
---

Analyze code for OWASP Top 10 vulnerabilities.
Focus on authentication, input validation, and data exposure.
Report findings with severity levels.

5. Use Memory Features

As you work, Copilot stores coding standards, project structure insights, and your preferred approaches. This makes future sessions progressively more productive.

Scripting Recipes

Automated Code Quality Check

#!/bin/bash
copilot -p "
1. Run eslint on src/
2. Run prettier --check
3. Run unit tests
4. Generate summary report
" --allow-all-tools --share > quality-report.md

Interactive Development Loop

#!/bin/bash
while true; do
  copilot --continue --model claude-sonnet-4.5
  read -p "Continue? (y/n) " choice
  [[ "$choice" != "y" ]] && break
done

Collaborative Review & Share

#!/bin/bash
copilot -p "Review changes in $(git diff --name-only)" \
  --model claude-opus-4.6 \
  --share-gist > review-url.txt

echo "Review shared at: $(cat review-url.txt)"

Best Practices

Context Management

• Use /compact before starting major new tasks within a session
• Use /clear to reset context when switching projects
• Let auto-compaction handle long sessions (triggers at 95% token limit)

Permission Safety

• Start restrictive, grant permissions as needed
• Use --allow-tool patterns for specific commands rather than blanket access
• Reserve --yolo for trusted local environments only
• Review tool usage with /session periodically

Custom Instructions Hierarchy

• User-level (~/.copilot/copilot-instructions.md) for personal preferences
• Repository-level (.github/copilot-instructions.md) for team standards
• Agent-specific (AGENTS.md) for specialized workflows

Session Workflow

• Use --continue to resume work immediately after breaks
• Use /share to document important sessions for future reference
• Use /share gist for sharing discoveries with your team

Advanced Patterns

Delegate to Copilot Coding Agent

# In interactive mode - pushes session to GitHub,
# opens draft PR, makes changes in background
/delegate

Explore Without Context Pollution

# Use the explore agent to ask questions
# without cluttering your main context
/agent explore
"How is authentication implemented?"
"Find all database queries in services/"

ACP Server for Third-Party Integration

# Start as Agent Client Protocol server
copilot --acp

# Or with TCP mode on a specific port
copilot --acp --port 3000

This allows third-party tools, IDEs, and automation systems to integrate with Copilot's agentic capabilities.

Enterprise Configuration Management

# Central config for team
export COPILOT_CUSTOM_INSTRUCTIONS_DIRS="/opt/company/copilot-config"

# Run with enterprise settings
copilot --config-dir /etc/copilot \
  --additional-mcp-config /etc/copilot/enterprise-mcp.json