What is GitHub Copilot?

GitHub Copilot is an AI coding assistant built by GitHub and Microsoft. It started in 2021 as inline code completions powered by an OpenAI model trained on public code, generally available a year later. By 2026 it has grown into something broader: a chat sidebar, a CLI, code review on pull requests, and an autonomous agent that can edit multiple files and run terminal commands inside your editor.

The original pitch - "AI pair programmer" - still describes it well, but the surface area is much larger than autocomplete. Most teams now think of Copilot as a layer in their tooling rather than a single feature.

The world's most widely adopted AI developer tool.- github.com/features/copilot

The three surfaces

Most of Copilot's day-to-day usage falls into one of three modes. They share the same model and the same context system, but they look and feel different.

  • Inline completions. The original product. As you type, Copilot suggests the rest of the line, the rest of the function, or a comment-driven block. Press Tab to accept, keep typing to ignore. This is the surface most developers use without thinking about it.
  • Chat. A sidebar (and, in some editors, an inline command palette) where you ask questions about the current file, the open workspace, or a specific selection. Chat can answer ("what does this regex do?"), refactor ("convert this to async/await"), or generate from scratch ("write tests for this module"). It can also run commands like /fix, /tests, /explain, and /doc.
  • CLI (gh copilot). A terminal command that explains a shell command, suggests one for a task, or pipes output through an explanation. Useful for the half of programming that happens outside the editor - git rebases, AWS CLI invocations, finding the right find flags.

The three surfaces are the same product, used differently. None of them replaces another; most teams use all three within a single hour.

The model picker

Copilot started on a single OpenAI Codex model. It now offers a model picker in chat - you choose which underlying model handles a given request from a list that includes GPT-class models from OpenAI, Claude models from Anthropic, and Gemini models from Google. The exact lineup changes; the point is that Copilot is no longer tied to one provider.

What this means in practice:

  • Different models, different strengths. Some teams prefer one model for long-context refactors and another for quick edits. The model picker is in the chat header.
  • Inline completions still use a fast model. The model behind autocomplete is optimized for latency - you need a suggestion in under a second, not the best possible answer in five.
  • Bring-your-own context is limited. The model has access to your open files, your repository (when configured), and what you tell it - not to your private cloud or third-party services unless GitHub or a connector explicitly supports it.

This evolution mirrors the broader market. The lesson Copilot teaches is that "which model" is a setting now, not an identity. The product is the integration, not the LLM.

Agent mode

The most significant addition since Copilot's launch is agent mode - released for VS Code in early 2025 and steadily expanding. Agent mode is Copilot operating as an autonomous coding agent: you describe a goal in natural language, and the agent reads files, edits multiple files, runs terminal commands, and iterates on its own until the goal is met (or it gives up and asks).

The shape of an agent-mode session:

  • You write a high-level instruction in the chat panel, with agent mode toggled on - "add a dark-mode toggle to the settings page, persist it in localStorage, and make sure the existing screenshot tests still pass."
  • The agent forms a plan and lists the files it intends to touch.
  • It edits those files, running the tests or the build between steps, reading the output, and adjusting.
  • You review each diff before accepting, or accept a batch.

Agent mode is the surface that puts Copilot in the same conversation as Claude Code and other autonomous coding agents. The difference is the host: Copilot's agent runs inside your editor and asks for your approval at every step; Claude Code runs in a terminal as a long-running session. Many teams use both, for different parts of the workflow.

Where it runs

Copilot is editor-agnostic by design. The official extensions cover:

  • Visual Studio Code - the most fully-featured surface, where new Copilot features land first. Includes inline completions, chat, agent mode, and the model picker.
  • Visual Studio - first-class on Windows; the .NET-shaped feature set tracks VS Code closely.
  • JetBrains IDEs - IntelliJ, PyCharm, WebStorm, Rider, GoLand and friends. Inline completions and chat are well-supported; agent mode is rolling out.
  • Neovim and Vim - inline completions through the official plugin, chat via a companion plugin.
  • Xcode - inline completions for Swift and Objective-C, added in 2024.
  • The browser (github.com) - Copilot in the web UI for code review, pull request summaries, issue triage, and the new Copilot Workspace task-oriented interface.

The point is reach. Wherever you write code, Copilot has a plausible answer. The depth of integration varies, but the inline-completion surface is consistent across all of them.

Plans and the free tier

GitHub Copilot is a paid product. The pricing tiers:

  • Free - introduced in late 2024 for personal GitHub accounts. Limited monthly completions and chat requests; no agent mode beyond a small allotment. Useful for trying Copilot or for very light usage.
  • Pro - the individual paid plan. Unlimited completions, chat, and agent mode; access to the model picker.
  • Business - for teams. Adds policy controls, audit logs, content exclusion (folders or files Copilot should not see), and SSO.
  • Enterprise - for larger organizations. Adds knowledge bases over your private repositories, fine-grained policy management, and SLAs.

Students, teachers, and maintainers of popular open-source projects get Pro free via GitHub's existing programs. Exact prices and quotas change; check github.com/features/copilot/plans for the current numbers.

Where Copilot fits

Copilot is most valuable in the cases that match its strengths:

  • Inline acceleration inside an existing editor workflow. If you live in VS Code or a JetBrains IDE and want AI help without changing tools, Copilot is the option of least friction.
  • Mainstream languages and frameworks. The completion quality is best on languages with a lot of public code - JavaScript, TypeScript, Python, Java, Go, C#, Ruby. Niche languages get suggestions but fewer correct ones.
  • Teams already on GitHub. Pull-request integration, issue triage, and the browser-based surfaces are the easiest sell when your code already lives on github.com.

Where Copilot fits less well: terminal-first workflows that want a long-running autonomous agent (Claude Code is closer in shape), private models running fully on-device, or organizations with strict policies forbidding any third-party model contact. Copilot is a hosted product; that is a feature for most teams and a constraint for some.

For the broader picture - where Copilot sits next to other AI tools developers use today - read AI stack 2026.

References