GitHub Copilot — The Ultimate Guide for Developers and DevOps Engineers.

GitHub Copilot is a full AI development platform — inline suggestions, chat, autonomous agents, cloud agents that open PRs, custom agents, MCP servers, 20+ AI models, and a standalone Agents window. This guide covers everything.

If You Read Nothing Else: Copilot has three surfaces — inline suggestions (autocomplete on steroids), chat (ask anything about code), and agent mode (autonomous multi-file coding). Each solves a different problem. The developers who get 10× value use all three, not just tab-complete. The default model is now GPT-5.3-Codex, but you can switch to Claude, Gemini, or 15+ other models per task.

This article assumes you've read Article 1: Fundamentals. If terms like "context window," "temperature," or "two-layer model" are unfamiliar, start there.

1. What GitHub Copilot Actually Is (Architecture)

GitHub Copilot is the tool layer from our fundamentals article. It sits between you and the model. Its job:

1. Gather context — your current file, open tabs, workspace structure, git history, terminal output, linter errors, custom instructions.
2. Build a prompt — assemble that context with your request into a structured prompt the model understands.
3. Send to a model — route to whichever LLM you've selected (GPT-5.3-Codex by default).
4. Present the response — inline ghost text, chat message, or applied file edits depending on the surface.

2. Plans and Pricing (May 2026)

Copilot has six plans. The differences matter — especially for teams deciding between Business and Enterprise.

Plan	Price	Premium Requests/mo	Key Features
Free	$0	50	2,000 completions/mo, 50 chat messages, basic models (GPT-4.1, GPT-5 mini), agent mode, MCP
Student	$0	300	Unlimited completions, premium models, cloud agent, code review
Pro	$10/mo	300	Everything in Student + GPT-5.3-Codex, Claude Sonnet 4.5, Gemini Pro
Pro+	$39/mo	1,500	Everything in Pro + Claude Opus 4.7, GPT-5.5, all models, GitHub Spark
Business	$19/seat/mo	300/user	Org-wide policies, audit logs, cloud agent, content exclusions
Enterprise	$39/seat/mo	1,000/user	Everything in Business + all models, file exclusions, org-wide instructions

Model multipliers — the hidden cost

Not all models cost the same. Each model has a multiplier that determines how many premium requests it consumes:

Model	Multiplier (Paid Plans)	What This Means
GPT-4.1 / GPT-4o / GPT-5 mini	0× (free)	Included models — never consume premium requests
Claude Haiku 4.5 / GPT-5.4 nano	0.25–0.33×	Budget models — great for quick tasks
Claude Sonnet 4.5 / GPT-5.3-Codex / Gemini 2.5 Pro	1×	Standard premium — one request per use
Claude Opus 4.5 / Opus 4.6	3×	Heavy — use selectively for complex tasks
GPT-5.5	7.5×	Very expensive — reserve for hardest problems
Claude Opus 4.7	15×	Most expensive — use only when nothing else works

Pro tip: Use auto model selection (let Copilot choose) to get a 10% discount on multipliers. A request that normally costs 1× premium request costs 0.9× with auto selection.

Starting June 1, 2026: GitHub is transitioning from request-based to usage-based billing. The premium request system will be replaced by metered usage billing. Keep an eye on your org's billing settings.

3. Surface 1: Inline Suggestions (Ghost Text + NES)

This is the original Copilot — dimmed ghost text that appears as you type. But it's evolved significantly.

Ghost text suggestions

As you type, Copilot predicts what comes next — from single-line completions to entire function bodies. It uses your current file, open tabs, and imports as context.

Keyboard shortcuts (macOS / Windows-Linux)

Action	macOS	Windows/Linux
Accept full suggestion	Tab	Tab
Accept next word	⌘→	Ctrl+→
Accept next line	⌘→ (hold)	Ctrl+→ (hold)
Dismiss suggestion	Esc	Esc
Next suggestion	⌥]	Alt+]
Previous suggestion	⌥[	Alt+[
Trigger suggestion manually	⌥\	Alt+\

Next Edit Suggestions (NES) — the game changer

NES is the evolution beyond autocomplete. Instead of predicting what comes next at your cursor, it predicts where you'll edit next and what that edit should be. An arrow in the gutter shows you where the next suggested edit is.

What NES catches

• Typos and logic mistakes: Change conts → const, fix inverted ternaries, catch || where you meant &&.
• Rename propagation: Rename a variable once, NES suggests updating it everywhere else in the file.
• Intent changes: Rename Point to Point3D and NES suggests adding a z property and updating methods.
• Paste adaptation: Copy-paste code from elsewhere, NES suggests adjusting it to match the current code style.

Enable NES: github.copilot.nextEditSuggestions.enabled: true in VS Code settings (may be managed by your org admin).

Making inline suggestions better

• Open related files. Copilot reads open tabs for context. If you're implementing a service, open the interface/types file.
• Write comments first. A comment like // Validate input: check email format, non-empty name, age > 0 gives Copilot a roadmap.
• Accept partially. Use ⌘→ to accept word-by-word. Take what's right, type what's wrong, let Copilot adjust.
• Change the completions model. Run GitHub Copilot: Change Completions Model from the Command Palette to try different models for inline suggestions.

4. Surface 2: Copilot Chat

Chat is where you have conversations with Copilot about your code. Open it with ⌃⌘I (macOS) or Ctrl+Alt+I (Windows/Linux).

Chat modes

When you open Chat, you pick an agent/mode from the dropdown:

• Ask: Read-only Q&A. Copilot answers questions but doesn't modify files. Good for learning, explaining code, debugging concepts.
• Edit: Copilot suggests changes to specific files you add to the working set. You review and accept/reject each change.
• Agent: Full autonomous mode. Copilot plans, edits files, runs terminal commands, and iterates. More on this in Section 5.

Inline Chat

Press ⌘I (macOS) / Ctrl+I (Windows/Linux) while your cursor is in the editor. A small chat prompt appears right where you're coding. Perfect for:

• Targeted refactors: "Convert this to async/await"
• Quick fixes: "Add error handling to this function"
• Explanations: "What does this regex do?"
• Generation: "Write tests for this function"

Slash commands

Type / in chat for built-in commands:

Command	What It Does
/explain	Explain selected code or a concept in plain English
/fix	Fix problems in selected code — reads the error, generates a fix
/tests	Generate tests for selected code using your project's test framework
/doc	Generate JSDoc/docstring documentation for selected code
/init	Scan your project and auto-generate .github/copilot-instructions.md. Run this first on every project.
/new	Scaffold a new project from scratch with framework and tooling of your choice
/clear	Clear the current chat history and start a fresh conversation
/search	Semantic search across the workspace — finds code by meaning, not just text

@ agents — scoping Copilot's reach

Use @ to invoke a specific agent that has domain expertise over a particular context:

Agent	What It Has Access To	Example
@workspace	Your entire project — searches all files for relevant context	@workspace where is the payment logic?
@vscode	VS Code itself — settings, extensions, commands	@vscode how do I configure the formatter?
@terminal	The integrated terminal — last command output, shell context	@terminal why did that build fail?
@github	GitHub — PRs, issues, commits, CI runs (requires GitHub MCP)	@github summarise PR #142

# context variables — attaching specific data

Use # to explicitly pin specific context into any prompt:

Variable	What it attaches
#file:path/to/file.ts	Full contents of a specific file
#selection	Currently selected text in the editor
#terminalLastCommand	Last terminal command + its full output
#terminalSelection	Selected text in the terminal
#problems	All current workspace errors and warnings from the Problems panel
#codebase	Relevant code retrieved from a semantic search across the whole codebase

Pro tip: Stack them. Fix the error in #file:server.ts — the failure was #terminalLastCommand and related errors are #problems gives Copilot the file, the runtime error, and the static diagnostics all at once.

5. Surface 3: Agent Mode — The Main Event

Agent mode is what makes Copilot in 2026 fundamentally different from 2024. Instead of suggesting code for you to apply, the agent does the work.

How agent mode works

1. You describe a goal: "Add rate limiting middleware to the Express API using a sliding window approach."
2. Agent plans: It analyzes your codebase, identifies relevant files, and creates a step-by-step plan.
3. Agent executes: It edits files, creates new files, suggests terminal commands (npm install express-rate-limit).
4. Agent self-corrects: If a command fails or tests break, it reads the error and tries again.
5. You review: Accept, reject, or redirect at any point.

Three types of agent sessions

Cloud agent deep dive

The cloud agent (formerly "Project Padawan") is Copilot's most powerful feature. Here's how it works:

1. Trigger: Assign a GitHub issue to Copilot, start a session from VS Code, or use the REST API.
2. Sandbox: Copilot spins up a secure cloud sandbox, clones your repo, and sets up the environment.
3. Execution: It reads the issue, analyzes the codebase (including custom instructions and memory), makes changes, and runs tests.
4. Output: A pull request with all changes, ready for human review.
5. Iteration: Review comments trigger the agent to make additional changes.

For DevOps: Cloud agents respect .github/copilot-instructions.md, understand CI configurations, and can be triggered via the REST API — meaning you can integrate them into automation workflows.

Agent Handoff — moving work between agent types

One of Copilot's most powerful (and least documented) capabilities is agent handoff — the ability to transfer a task from one agent type to another while preserving context. This means you can start work locally, then hand it off to run in the background or cloud without losing what the agent already knows.

Local → Background handoff

When a local agent session is taking too long (running tests, processing large migrations, doing bulk refactors), you can hand it off to a background agent:

1. In the Copilot chat panel, click the "Continue in Background" option (or use the @workspace /background command).
2. The agent's full context — files it has read, changes planned, conversation history — transfers to the background session.
3. You continue working on other things. The background agent proceeds autonomously.
4. When it finishes, you get a notification. Review and accept/reject the changes.

Local → Cloud handoff

For tasks that should result in a PR (especially when you want CI to validate the changes):

1. After scoping the work locally (discussing approach, identifying files), select "Create PR with Copilot".
2. The agent creates a cloud session with your local context — the issue description, relevant files, and your instructions.
3. It runs in GitHub's infrastructure: makes changes, runs tests in the sandbox, and opens a PR.
4. You review asynchronously, just like any other PR.

What transfers during handoff

• Conversation history: Everything you discussed with the agent carries over.
• File context: Files the agent has read or plans to modify.
• Custom instructions: Your .github/copilot-instructions.md and workspace rules.
• Task plan: If the agent had broken the work into steps, the plan transfers.

What does NOT transfer

• Local tool state: Terminal sessions, running servers, debug sessions.
• Uncommitted changes: Background/cloud agents work from the repo state. Commit your changes first.
• MCP server connections: Cloud agents use their own environment — custom MCP servers won't be available unless configured for the cloud.

Pro tip: The handoff pattern is ideal for DevOps workflows. Start locally to debug a CI pipeline, then hand off to the cloud agent to implement and test the fix across the full matrix. The cloud agent can run in environments you might not have locally.

6. Choosing the Right Model

Copilot gives you access to 20+ AI models. Don't just use the default — different models excel at different tasks.

Model selection guide

Task	Recommended Model	Why
Day-to-day coding, autocomplete	GPT-5 mini or GPT-4.1	Free (0× multiplier), fast, good enough for most tasks
Complex feature implementation	GPT-5.3-Codex	Default for a reason — optimized for code generation with reasoning
Large codebase refactoring	Claude Opus 4.6	Best at understanding large context and making coordinated changes
Processing massive files	Gemini 2.5 Pro	1M token context — can read entire repos
Quick cheap tasks	Claude Haiku 4.5 or GPT-5.4 nano	0.25–0.33× multiplier — saves premium requests
Architecture/design decisions	Claude Opus 4.7 or GPT-5.5	Best reasoning, but expensive (7.5–15× multiplier)
Fast iteration	Gemini 3 Flash or GPT-5.4 mini	Low latency, good quality, cheap

Switch models mid-conversation: Click the model name in the Chat view to change models. The conversation context is preserved. Use this to "escalate" — start with a cheap model, switch to a premium one when the task gets hard.

Auto model selection

Let Copilot pick the model automatically based on your task. Available for Chat, CLI, and cloud agent. Benefits:

• 10% discount on multipliers (1× becomes 0.9×).
• Copilot routes simple tasks to cheap models and complex tasks to powerful ones.
• No decision fatigue — just prompt and go.

7. Customization — Making Copilot Work for Your Team

Out-of-the-box Copilot is generic. Customized Copilot understands your codebase, follows your conventions, and produces code that looks like your team wrote it.

Custom instructions

The most impactful customization. Create .github/copilot-instructions.md in your repo:

# Project Coding Guidelines

## Stack
- TypeScript 5.5, Next.js 15 (App Router), Prisma ORM
- Tailwind CSS for styling, no CSS modules
- pnpm as package manager

## Conventions
- Named exports only (no default exports except pages)
- Use `const` arrow functions for components
- Zod schemas for all API input validation
- Error responses use RFC 7807 Problem Details format

## Architecture
- `src/app/` — Next.js routes (App Router)
- `src/lib/` — shared utilities and clients
- `src/services/` — business logic layer
- `src/generated/` — DO NOT EDIT (Prisma generated)

## Testing
- Vitest for unit tests, Playwright for e2e
- Run `pnpm test` before suggesting changes are complete
- Minimum 80% coverage for new code

Folder-scoped instructions

Create .instructions.md files in subdirectories for context-specific rules:

• src/api/.instructions.md — "All API routes must validate input with Zod and return typed responses."
• infra/.instructions.md — "Use Terraform 1.9 syntax. All resources must have environment and team tags."

Prompt files (.prompt.md)

Reusable prompt templates stored in your workspace. Create .github/prompts/add-api-endpoint.prompt.md:

---
description: Create a new API endpoint following our conventions
---
Create a new API endpoint at the path specified by the user.

Follow these rules:
1. Create a route handler in `src/app/api/`
2. Add Zod schema validation for all inputs
3. Use the service layer for business logic
4. Add unit tests with Vitest
5. Update the OpenAPI spec in `docs/api.yaml`

Then in chat, reference it: "Use the add-api-endpoint prompt to create a /api/orders endpoint."

Custom agents

Create specialized AI personas with their own instructions and tool restrictions. Store in .github/agents/:

# .github/agents/Reviewer.agent.md
---
name: 'Reviewer'
description: 'Code review agent — analysis only, no changes.'
tools: ['read', 'search', 'web', 'vscode/askQuestions']
---
You are a senior developer conducting code review.
Focus on: security, performance, maintainability.
DO NOT make code changes. Only provide analysis.

Custom agents appear in the agent picker dropdown. Your team can have a Reviewer, a Security Scanner, a Documentation Writer, a Migration Helper — each with specialized behavior.

8. MCP Servers — Extending Copilot's Reach

Model Context Protocol servers give Copilot access to external tools and data. Configure them in .vscode/mcp.json or VS Code settings.

Why MCP matters for DevOps

Without MCP, Copilot can only see your code. With MCP, it can:

• Query databases: "Show me the top 10 slowest queries from our production Postgres."
• Check monitoring: "What alerts fired in the last hour on our Datadog dashboard?"
• Read docs: "What does our internal API documentation say about the auth flow?"
• Interact with infra: "List all Kubernetes pods in the staging namespace that are in CrashLoopBackOff."

Setting up an MCP server

// .vscode/mcp.json
{
  "servers": {
    "postgres": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres"],
      "env": {
        "DATABASE_URL": "${input:databaseUrl}"
      }
    },
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_TOKEN": "${input:githubToken}"
      }
    }
  }
}

MCP servers work across all agent modes — local, background, and cloud. One server definition works in Copilot, Claude Code, Cursor, and any MCP-compatible tool.

9. Agent Skills — Teaching Copilot Domain Expertise

Skills are folders of instructions, scripts, and resources that Copilot loads when relevant. They're more focused than custom instructions — think "mini knowledge packs."

# .github/skills/terraform-module/SKILL.md
---
description: "Create Terraform modules following our conventions."
applyWhen: "User asks to create infrastructure, terraform, or IaC."
---
When creating Terraform modules:
1. Use our module template from `infra/templates/`
2. All resources must have standard tags
3. Use `terraform fmt` and `tflint` before committing
4. Include a README.md with usage examples

Skills are automatically loaded when relevant — Copilot reads the description and applyWhen fields to decide when to activate them.

10. Copilot CLI — AI in Your Terminal

Copilot isn't just in VS Code. gh copilot brings AI to your terminal.

Key commands

# Ask Copilot about shell commands
gh copilot suggest "find all log files larger than 100MB modified in the last 7 days"

# Explain a command
gh copilot explain "awk '{sum+=$5} END {print sum}' access.log"

# Start an agent session from CLI
gh copilot agent "Add rate limiting to the Express API"

# Plan a task
gh copilot plan "Migrate from Docker Compose to Kubernetes"

CLI agent sessions

As of May 2026, CLI agent sessions can be started in the terminal and continued in VS Code or on GitHub.com. The context carries over. Start a task on your laptop, continue reviewing on your phone via GitHub Mobile.

11. Code Review with Copilot

Copilot can review code in two places:

PR code review (GitHub.com)

• Assign Copilot as a reviewer on any PR.
• It analyzes the diff, checks for bugs, security issues, and style violations.
• Comments directly on the PR with inline suggestions.
• Costs 1 premium request per review.

IDE code review (VS Code)

• Select code → right-click → "Copilot: Review Selection."
• Available on all plans (including Free).
• Good for pre-commit self-review.

For teams: Set up auto-assignment so every PR gets a Copilot review before human review. It catches the mechanical stuff (missing error handling, unused imports, obvious bugs) so human reviewers can focus on architecture and design.

12. Copilot Memory and Spaces

Copilot Memory

Copilot can deduce and store useful information about a repository. Cloud agents and code review use this memory to improve output quality. It learns things like:

• Your project's coding patterns and conventions.
• Common file structures and naming conventions.
• Frequently used libraries and their versions.

As of May 15, 2026, Copilot Memory also supports user preferences for Pro and Pro+ users — it remembers your individual coding style across repositories.

Copilot Spaces

Organize relevant content — code, docs, specs, design files — into "Spaces" that give Copilot the right context for specific tasks. Think of it as curated context packages.

• Create a "Payment Integration" space with the Stripe docs, your payment service code, and the API spec.
• Create an "Infra Migration" space with your current Terraform configs, the target architecture doc, and the migration checklist.
• Anyone on the team can use the space — shared context for shared work.

13. Smart Actions — AI Baked Into VS Code

Smart actions are pre-built AI operations that appear contextually in VS Code's UI. No prompting required.

Actions you should know

• Generate commit message: Click the sparkle icon in Source Control. AI analyzes your staged changes and writes a descriptive conventional commit message.
• Fix with Copilot: When you see a squiggly error, hover → Quick Fix → "Fix with Copilot." It reads the error and generates a fix.
• Generate tests: Right-click a function → "Copilot: Generate Tests." Creates a test file with relevant cases.
• Explain this: Select code → right-click → "Copilot: Explain This." Gets a plain-English explanation.
• Rename symbol: AI-powered rename suggestions that understand context.
• Semantic search: Search your project by meaning, not just text. "Where do we validate user input?" finds all validation code even if it doesn't contain the word "validate."

14. Hooks — Automation on Agent Events

Hooks let you run custom commands when specific events happen during agent sessions. Configure in VS Code settings:

// .vscode/settings.js?v=6on
{
  "github.copilot.chat.agent.hooks": {
    "afterSave": {
      "command": "pnpm lint --fix ${file}",
      "when": "resourceExtname == '.ts'"
    },
    "beforeSubmit": {
      "command": "pnpm test --related",
      "failBehavior": "warn"
    }
  }
}

Use cases for DevOps:

• Auto-lint after every file save.
• Run related tests before the agent considers a task complete.
• Format Terraform files after edits.
• Policy enforcement: block agent from modifying certain directories.

15. The Agents Window (Preview)

VS Code now has a dedicated Agents window — a separate, agent-first surface alongside the traditional editor window.

When to use the Agents window vs the Editor window

Agents Window	Editor Window
Thinking in prompts	Writing code with AI assist
Managing multiple agent sessions	Interactive development
Reviewing changes in a dedicated panel	Debugging with breakpoints
Configuring agents, skills, MCP	Using extensions and views
Orchestrating across projects	Working in a single project

Both windows share agent sessions and VS Code configuration. Switch between them freely — start in the editor, hand off to the agents window for review, then come back to the editor.

16. GitHub Spark — From Prompt to App (Preview)

Spark lets you build and deploy full-stack applications using natural language prompts. It's integrated with GitHub's platform for deployment and sharing.

• Available on Pro+ and Enterprise plans.
• Each prompt costs 4 premium requests (fixed rate).
• Good for internal tools, prototypes, and utility apps.

17. Copilot for DevOps — Practical Workflows

Here's where this gets specific. These are real workflows for DevOps engineers using Copilot daily.

Workflow 1: Debugging a production incident

# In VS Code agent mode:
"Our /api/users endpoint is returning 503s.
Read the Kubernetes pod logs from #terminalLastCommand,
check the health check endpoint implementation,
and identify the root cause."

Workflow 2: Writing Terraform modules

# With custom instructions for IaC:
"Create a Terraform module for an AWS ECS Fargate service
with ALB, autoscaling, and CloudWatch alarms.
Follow the patterns in infra/modules/existing-service/."

Workflow 3: CI/CD pipeline debugging

# With GitHub MCP server connected:
"Our CI pipeline is failing on the main branch.
Read the latest workflow run logs, identify the failure,
and suggest a fix for the .github/workflows/ci.yml."

Workflow 4: Dockerfile optimization

# Inline chat with Dockerfile selected:
"Optimize this Dockerfile for smaller image size
and faster builds. Use multi-stage builds, minimize layers,
and ensure no dev dependencies in the final image."

Workflow 5: Security scanning

# Using the Reviewer custom agent:
"Review all files in src/api/ for security vulnerabilities:
SQL injection, XSS, CSRF, auth bypass, and secret leakage."

18. Tips That Actually Matter

1. Start with the free models. GPT-4.1 and GPT-5 mini cost 0× premium requests. Use them for everything routine. Escalate to premium models only when needed.
2. Use /init on every project. It auto-generates custom instructions by analyzing your codebase. Five seconds, permanent benefit.
3. Keep conversations short. Start a new chat for each task. Long conversations accumulate noise and context drift.
4. Reference existing code. "Follow the pattern in src/services/userService.ts" beats a paragraph of description.
5. Accept partially, iterate. Don't reject entire suggestions because of one wrong line. Accept the good parts, fix the rest.
6. Use the Sessions view. Run multiple agent sessions in parallel — one debugging, one implementing, one writing tests. Switch between them.
7. Monitor your premium requests. Go to github.com/settings/copilot to see usage. With the June 2026 billing change, this becomes even more important.
8. Learn to hand off. Start a task locally → hand off to background when it's clear → review the output. Don't sit and watch the agent type.
9. Read the diffs. Always. Every time. AI-generated code that you don't read is technical debt you chose not to understand.
10. Enable NES. Next Edit Suggestions alone are worth the subscription. They catch bugs before you notice them.

19. Keyboard Shortcut Reference

Action	macOS	Windows/Linux
Open Chat view	⌃⌘I	Ctrl+Alt+I
Open Inline Chat	⌘I	Ctrl+I
Accept inline suggestion	Tab	Tab
Accept next word	⌘→	Ctrl+→
Dismiss suggestion	Esc	Esc
Next/prev suggestion	⌥] / ⌥[	Alt+] / Alt+[
Trigger suggestion	⌥\	Alt+\
Quick Fix (Copilot)	⌘.	Ctrl+.
Command Palette	⇧⌘P	Ctrl+Shift+P

What's Next

GitHub Copilot is the Swiss Army knife — it does everything, integrates everywhere, and has the deepest IDE experience. But it's not the only tool worth knowing.

Next in the series: Codex — The Ultimate Guide. OpenAI's cloud-native coding agent that runs autonomously in sandboxed environments, creates PRs, and integrates directly with your CI pipeline. A different philosophy from Copilot — and worth understanding for teams that want to delegate entire tasks.

After that: Claude Code — The Ultimate Guide. The terminal-native agent with the deepest reasoning capabilities and the best understanding of large, complex codebases.