Github Copilot Cli Expert

GitHub Copilot CLI Expert

Comprehensive knowledge of GitHub Copilot CLI - the terminal-native AI coding assistant.

Note: Command syntax and model availability may change. Run /help in Copilot CLI for current options.

Purpose

This skill provides expert guidance on:

1. Installing and updating GitHub Copilot CLI 2. All slash commands and keyboard shortcuts 3. Custom agents, skills, and MCP server configuration 4. Security, permissions, and trusted directories 5. Integration with GitHub workflows (PRs, issues, Actions) 6. Programmatic and interactive usage modes

Quick Reference

Installation (Pick One)

# Homebrew (macOS/Linux) - Recommended
brew install copilot-cli

# npm (all platforms, requires Node.js 22+)
npm install -g @github/copilot

# WinGet (Windows)
winget install GitHub.Copilot

# Install script (macOS/Linux)
curl -fsSL https://gh.io/copilot-install | bash

Update to Latest Version

# Homebrew
brew upgrade copilot-cli

# npm
npm update -g @github/copilot

# WinGet
winget upgrade GitHub.Copilot

# Check version
copilot --version

Before First Use

Requirements:

• Active GitHub Copilot subscription (Plans)
• Node.js 22+ (if installing via npm)
• PowerShell v6+ (Windows users)

Authentication:

# On first run, you'll be prompted to login
copilot
# Then: /login

# OR set environment variable
export GH_TOKEN="ghp_xxxxxxxxxxxx"

Essential Slash Commands

Keyboard Shortcuts

When to Use This Skill

Auto-triggers when user mentions:

• "copilot cli", "github copilot", "install copilot"
• "update copilot", "copilot version", "copilot commands"
• "mcp server", "custom agents", "copilot skills"

Explicitly invoke via:

Skill(skill="github-copilot-cli-expert")

Navigation Guide

When to Read Supporting Files

reference.md - Read when you need:

• Complete list of all slash commands with detailed options
• All command-line flags and environment variables
• Detailed security configuration (trusted directories, tool permissions)
• Programmatic mode examples and scripting patterns
• MCP server configuration JSON format

examples.md - Read when you need:

• Step-by-step workflow examples (PR creation, code review)
• Custom agent creation and invocation examples
• GitHub integration use cases (issues, Actions, PRs)
• Delegation to Copilot coding agent workflows

Core Capabilities

1. Interactive vs Programmatic Mode

Interactive (default):

copilot
# Then type prompts naturally

Programmatic (scripting):

copilot -p "Summarize recent commits" --allow-tool 'shell(git)'

2. Custom Agents

Built-in agents: explore, task, plan, code-review

Custom agent locations:

• User-level: ~/.copilot/agents/
• Repository: .github/agents/
• Org/Enterprise: .github-private/agents/

3. MCP Servers

GitHub MCP server included by default. Add more:

/mcp add
# Fill details, Ctrl+S to save

Config stored in: ~/.copilot/mcp-config.json

4. Security Model

• Trusted directories: Confirmed on first launch
• Tool approval: Required for file modifications
• Path permissions: Current directory + temp by default
• URL permissions: All URLs require approval

Common Patterns

Include Files in Prompts

Explain @config/settings.yml
Fix the bug in @src/app.js

Delegate to GitHub Agent

/delegate complete the API tests and create a PR

Resume Previous Session

copilot --resume    # Cycle through sessions
copilot --continue  # Resume most recent

Allow Tools Without Prompts

copilot --allow-all-tools
copilot --allow-tool 'shell(git)'
copilot --deny-tool 'shell(rm)'

Version Information

Current Version: Check with copilot --version

Prerelease Channels:

brew install copilot-cli@prerelease
npm install -g @github/copilot@prerelease
winget install GitHub.Copilot.Prerelease

Releases: https://github.com/github/copilot-cli/releases/

Troubleshooting

Authentication Issues

/login              # In interactive mode
# Or use PAT with GH_TOKEN/GITHUB_TOKEN env var

Context Window Full

/compact            # Summarize conversation
/context            # View token usage

MCP Server Not Loading

/mcp show           # List configured servers
/mcp edit [name]    # Edit configuration

Tool Permission Denied

• Check trusted directories: ~/.copilot/config.json → trusted_folders
• Use --allow-all-paths or --allow-all-urls flags
• Approve tools individually when prompted

First-Time Setup Issues

"Copilot not found" after install:

• Restart terminal after installation
• Check PATH includes install location
• Run which copilot (Unix) or where copilot (Windows)

"No subscription" error:

• Verify at https://github.com/settings/copilot
• Ensure plan includes CLI access
• Try /logout then /login

Related Skills

• mcp-manager: Advanced MCP server configuration
• agent-sdk: Building custom agents
• documentation-writing: Clear documentation practices

Official Resources

• Docs: https://docs.github.com/copilot/concepts/agents/about-copilot-cli
• Usage Guide: https://docs.github.com/copilot/how-tos/use-copilot-agents/use-copilot-cli
• Installation: https://docs.github.com/copilot/how-tos/set-up/install-copilot-cli
• Releases: https://github.com/github/copilot-cli/releases/
• Feedback: Use /feedback command in CLI

GitHub Copilot CLI Examples

Practical examples and workflows for GitHub Copilot CLI.

Local Development Workflows

Example 1: Code Understanding

Scenario: Understand a new codebase

# Start Copilot in your project
cd /path/to/project
copilot

# Ask about the project
What does this codebase do?

# Explore specific files
Explain @src/main.py

# Understand dependencies
What libraries does this project use and why?

# Find patterns
Show me how authentication is handled in this codebase

Example 2: Bug Fixing

Scenario: Debug and fix an issue

copilot

# Describe the problem
The API returns 500 error when users submit forms with empty fields

# Let Copilot investigate
Show me the form validation logic in @src/api/forms.py

# Get fix suggestions
Fix the validation to properly handle empty fields

# Review the changes before committing
/diff

Example 3: Feature Implementation

Scenario: Add a new feature

copilot

# Describe the feature
Add a rate limiting middleware that limits requests to 100 per minute per IP

# Get implementation plan first
/plan implement rate limiting for the API

# Implement with guidance
Create the rate limiter following the plan

# Test it
Run the tests and show me the results

GitHub Integration Workflows

Example 4: Creating Pull Requests

Scenario: Make changes and create a PR

copilot

# Make code changes
Add input validation to the user registration endpoint

# Review what changed
/diff

# Create PR directly on GitHub
Create a pull request for these changes with a descriptive title and body

Expected: Copilot creates a PR on GitHub with you as the author.

Example 5: Working with Issues

Scenario: Address an assigned issue

copilot

# Start from an issue
I've been assigned issue https://github.com/myorg/myrepo/issues/42
Start working on this in a new branch

# Copilot will:
# 1. Create a branch
# 2. Read the issue
# 3. Start implementing

Example 6: Code Review

Scenario: Review a PR for issues

copilot

# Review a specific PR
Check the changes in PR https://github.com/myorg/myrepo/pull/123
Report any bugs, security issues, or code quality problems

# Get summary of findings
Copilot provides inline analysis of the PR changes

Example 7: Managing PRs

Scenario: Merge or close PRs

copilot

# Merge approved PRs
Merge all approved PRs I've created in myorg/myrepo

# Close a specific PR
Close PR #45 on myorg/myrepo with a comment explaining why

Delegation Workflows

Example 8: Delegate to Copilot Agent

Scenario: Hand off work to run in background on GitHub

copilot

# Start with some local context
I've been working on the authentication refactor

# Delegate remaining work
/delegate complete the password reset flow and fix the test failures

# Copilot will:
# 1. Create a checkpoint commit
# 2. Push to a new branch
# 3. Open a draft PR
# 4. Run Copilot coding agent in background
# 5. Provide link to PR and agent session

Example 9: Resume Remote Session

Scenario: Bring GitHub agent work back locally

# List available sessions
copilot --resume

# Select the session from the delegation
# Now you can continue the work locally

Custom Agent Workflows

Example 10: Using Built-in Agents

Scenario: Quick codebase exploration

copilot

# Use explore agent (doesn't add to main context)
Use the explore agent to find all API endpoints in this project

# Use plan agent for complex tasks
Use the plan agent to create an implementation plan for adding OAuth support

# Use code-review agent
Use the code-review agent to review the changes in the staging branch

Example 11: Creating Custom Agents

Step 1: Create agent file at ~/.copilot/agents/security-checker.md:

# Security Checker Agent

You are a security-focused code reviewer. When reviewing code:

1. Check for SQL injection vulnerabilities
2. Look for XSS vulnerabilities
3. Identify authentication/authorization issues
4. Flag sensitive data exposure
5. Check for insecure dependencies

Always provide severity ratings (Critical/High/Medium/Low) and
remediation suggestions.

Step 2: Use the agent:

copilot --agent=security-checker

Review @src/api/ for security issues

Example 12: Repository-Level Agents

Create .github/agents/frontend-expert.md in your repo:

# Frontend Expert

You specialize in React and TypeScript development for this project.

Follow these conventions:

- Use functional components with hooks
- Prefer TypeScript strict mode
- Use our component library from @/components
- Follow accessibility best practices

Then use it:

copilot

Use the frontend-expert agent to create a new dashboard component

MCP Server Workflows

Example 13: Adding MCP Servers

Add filesystem access to additional directories:

copilot

/mcp add

# Fill in:
# Name: my-docs
# Command: npx
# Args: -y @modelcontextprotocol/server-filesystem /path/to/docs

# Press Ctrl+S to save

Example 14: Using GitHub MCP Server

The GitHub MCP server is included by default:

copilot

# Search issues
Use the GitHub MCP server to find good first issues in octocat/hello-world

# List workflow runs
Show me the recent GitHub Actions runs for this repo

# Manage labels
Add the "needs-review" label to issue #42

Programmatic Workflows

Example 15: CI/CD Integration

In your GitHub Actions workflow:

- name: Generate Docs
  run: |
    copilot -p "Generate API documentation for src/api/" \
      --allow-tool 'write' \
      --allow-tool 'shell(npm)'

Example 16: Scripted Code Generation

#!/bin/bash
# generate-tests.sh

copilot -p "Generate unit tests for $1" \
  --allow-tool 'write' \
  --allow-tool 'shell(npm test)'

Usage:

./generate-tests.sh src/utils/validator.ts

Example 17: Batch Operations

# Fix linting in all files, auto-approve common tools
copilot -p "Fix all ESLint errors in src/" \
  --allow-all-tools \
  --deny-tool 'shell(rm)' \
  --deny-tool 'shell(git push)'

Context Management

Example 18: Managing Large Sessions

copilot

# Work on a complex feature...
# (many prompts later)

# Check context usage
/context

# If approaching limit, summarize
/compact

# View session statistics
/usage

Example 19: Session Persistence

# End session, then later:
copilot --continue  # Resume last session

# Or pick from list
copilot --resume  # Shows all sessions

Example 20: Sharing Sessions

copilot

# After a productive session, share it:

# Export to file
/share file ./session-notes.md

# Or share as gist
/share gist

GitHub Actions Workflows

Example 21: Create Workflow

copilot

Create a GitHub Actions workflow that:
1. Runs on pull requests to main
2. Runs ESLint on changed files
3. Shows errors as PR annotations
4. Fails the check if there are errors
5. Push the workflow file and create a PR

Example 22: Debug Failing Actions

copilot

The CI pipeline is failing. Check the workflow file at .github/workflows/ci.yml
and the recent run logs to diagnose the issue.

# Copilot can access GitHub Actions data via MCP

Security-Conscious Workflows

Example 23: Restricted Automation

# Allow git read-only, deny destructive commands
copilot -p "Analyze the git history and summarize changes" \
  --allow-tool 'shell(git log)' \
  --allow-tool 'shell(git show)' \
  --allow-tool 'shell(git diff)' \
  --deny-tool 'shell(git push)' \
  --deny-tool 'shell(git reset)' \
  --deny-tool 'shell(rm)'

Example 24: Read-Only Analysis

# Deny all write operations
copilot -p "Audit this codebase for security issues" \
  --deny-tool 'write' \
  --deny-tool 'shell'

Tips & Best Practices

Effective Prompts

Good prompts are specific:

# Instead of:
Fix the bug

# Say:
Fix the TypeError in @src/api/users.py line 42 where user.email
is accessed before checking if user exists

Using File References

# Reference multiple files
Explain the relationship between @src/models/user.py and @src/api/auth.py

# Reference directories
Review all files in @tests/ for test coverage gaps

Iterative Development

# Build incrementally
Create the data model for a blog post

# Then extend
Add validation to the BlogPost model

# Then integrate
Create an API endpoint to create blog posts

# Review everything
/diff

Working with Large Codebases

# Use explore agent to keep main context clean
Use explore agent: How is caching implemented?

# Then focus on specific areas
Show me @src/cache/redis.py in detail

GitHub Copilot CLI Reference

Complete reference documentation for GitHub Copilot CLI.

All Slash Commands

Session Management

Configuration & Tools

File & Directory Access

Authentication & User

Task Delegation

Help & Feedback

Command-Line Options

Basic Options

copilot [options]

Options:
  -p, --prompt <text>     Run with single prompt (programmatic mode)
  --resume                Cycle through and resume sessions
  --continue              Resume most recent session
  --agent <name>          Specify custom agent to use
  --banner                Show animated banner
  --version               Show version number
  --help                  Show help

Tool Approval Options

--allow-all-tools         Allow all tools without approval
--allow-tool <spec>       Allow specific tool (repeatable)
--deny-tool <spec>        Deny specific tool (repeatable)

Tool Specification Formats:

• 'shell' - All shell commands
• 'shell(git)' - Specific command
• 'shell(git push)' - Command with subcommand
• 'write' - File modification tools
• 'MCP_SERVER_NAME' - All tools from MCP server
• 'MCP_SERVER_NAME(tool_name)' - Specific MCP tool

Path & URL Options

--allow-all-paths         Disable path verification
--allow-all-urls          Disable URL verification
--allow-url <domain>      Pre-approve specific domain

Environment Variables

Configuration Files

Main Configuration

Location: ~/.copilot/config.json

{
  "trusted_folders": ["/path/to/trusted/project1", "/path/to/trusted/project2"],
  "theme": "auto",
  "model": "claude-sonnet-4-5"
}

MCP Server Configuration

Location: ~/.copilot/mcp-config.json

{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_TOKEN": "${GH_TOKEN}"
      }
    },
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/path/to/dir"]
    }
  }
}

Custom Instructions Locations

Copilot CLI reads instructions from (in order):

1. CLAUDE.md (in git root & cwd) 2. GEMINI.md (in git root & cwd) 3. AGENTS.md (in git root & cwd) 4. .github/instructions/**/*.instructions.md (in git root & cwd) 5. .github/copilot-instructions.md 6. $HOME/.copilot/copilot-instructions.md 7. COPILOT_CUSTOM_INSTRUCTIONS_DIRS (additional directories via env var)

Custom Agents

Built-in Agents

Agent Loading Locations

Invoking Custom Agents

# Interactive - select from list
/agent

# In prompt - auto-infer
Use the refactoring agent to clean up this code

# Command-line - explicit
copilot --agent=my-agent --prompt "Do the thing"

Security Model

Trusted Directories

On first launch, you're asked to trust the current directory:

1. Yes, proceed - Trust for this session only 2. Yes, and remember - Trust for all future sessions 3. No, exit - Cancel session

Edit permanently: ~/.copilot/config.json → trusted_folders array

Tool Approval Flow

When Copilot needs to use a potentially dangerous tool:

1. Yes - Allow this time only 2. Yes, approve for session - Allow all uses of this tool type in session 3. No (Esc) - Cancel and provide different instruction

Permission Scopes

Path Permissions:

• Default: Current directory, subdirectories, system temp
• Limitations: Custom env vars not expanded, symlinks resolved only for existing files

URL Permissions:

• Default: All URLs require approval
• Limitations: URLs in files/configs not detected, obfuscated URLs may bypass

Risk Mitigation

For automated workflows with --allow-all-tools:

• Use in VMs, containers, or isolated environments
• Restrict network access
• Use specific --deny-tool for dangerous commands

Models

Available Models

Use /model to see current options. Typical choices:

• Claude Sonnet 4.5 (1x) - Default
• Claude Sonnet 4 (1x)
• GPT-5 (varies)
• Additional models based on subscription

Premium Request Multipliers

Each prompt costs premium requests × model multiplier. Check /model for current multipliers.

Help Commands (Terminal)

copilot help           # General help
copilot help config    # Configuration settings
copilot help environment  # Environment variables
copilot help logging   # Logging levels
copilot help permissions  # Tool permissions

Programmatic Mode Examples

Simple Query

copilot -p "What does this repo do?"

With Tool Approval

copilot -p "Run the tests" --allow-tool 'shell(npm)'

Full Automation

copilot -p "Fix linting errors and commit" \
  --allow-all-tools \
  --deny-tool 'shell(git push)' \
  --deny-tool 'shell(rm)'

Piping Input

echo "Explain this code" | copilot
cat script.sh | copilot -p "What does this do?"

Prerequisites

• Active Copilot subscription (Plans)
• Windows: PowerShell v6+
• npm install: Node.js 22+

Version Management

Check Version

copilot --version

Upgrade Commands

# Homebrew
brew upgrade copilot-cli

# npm
npm update -g @github/copilot

# WinGet
winget upgrade GitHub.Copilot

# Install script (reinstall latest)
curl -fsSL https://gh.io/copilot-install | bash

Install Specific Version

# npm
npm install -g @github/copilot@0.0.393

# Install script
curl -fsSL https://gh.io/copilot-install | VERSION="v0.0.393" bash

Prerelease Channel

brew install copilot-cli@prerelease
npm install -g @github/copilot@prerelease
winget install GitHub.Copilot.Prerelease

Direct Download

Executables available at: https://github.com/github/copilot-cli/releases/

Troubleshooting

"Copilot not found"

Ensure installation path is in $PATH:

• Homebrew: /opt/homebrew/bin or /usr/local/bin
• npm: Global npm bin directory
• Script: $HOME/.local/bin or /usr/local/bin

"Not logged in"

# In interactive mode
/login

# Or set environment variable
export GH_TOKEN="ghp_xxxxxxxxxxxx"

"Tool permission denied"

• Add directory to trusted: /add-dir /path
• Or restart with --allow-all-paths

"Context window full"

/compact    # Summarize and free space
/clear      # Start fresh (loses context)

MCP Server Errors

/mcp show          # Check status
/mcp edit <name>   # Fix configuration
/mcp disable <name> # Temporarily disable