GitHub Copilot

On this page 7

GitHub Copilot is an AI coding assistant developed by GitHub that uses large language models to suggest code, answer programming questions and carry out development tasks inside code editors, the command line and GitHub repositories. Among AI models & assistants, it is one of the most widely adopted developer-focused products, built around existing workflows rather than a separate chat application.

Artificial intelligence first reached mainstream software development through tools of this kind. Copilot entered technical preview in 2021, originally powered by OpenAI Codex, and became generally available in 2022. It has since grown from inline autocompletion into a family of features that includes chat, an agent mode in the editor and an autonomous coding agent that works on assigned issues and opens pull requests.

How GitHub Copilot generates suggestions

Copilot works by sending a prompt assembled from the developer context to a hosted language model and returning the generated output to the editor. The editor extension gathers the code around the cursor, content from open tabs and related files, the file language and, for chat, the user question. This context is trimmed to fit the model context window, filtered, and sent to GitHub services that route it to the selected model.

For inline completion, the model predicts the most likely continuation and the editor shows it as ghost text that the developer accepts or ignores. Completion models are tuned for low latency, because suggestions must appear while the developer types. Chat and agent features use larger models that can reason over longer context, read files on request and call tools such as the terminal or a test runner.

Copilot is no longer tied to one model. Depending on plan and administrator policy, users can choose among models from several providers, including OpenAI, Anthropic and Google model families. This multi-model approach lets teams trade speed against reasoning quality, but it also means output quality varies with the selected model.

Main Copilot features

Copilot is a set of related features that differ in scope and degree of autonomy. The table below compares the main ones.

FeatureWhere it runsWhat it doesAutonomy level
Code completionEditorSuggests the next lines as the user typesLow, user accepts each suggestion
Copilot ChatEditor, GitHub website, mobileAnswers questions, explains and edits codeLow to medium
Agent modeEditorPlans multi-file edits, runs commands, iterates on errorsMedium, user supervises in session
Coding agentGitHub cloud environmentWorks on an assigned issue and opens a pull requestHigh, reviewed through the pull request
Code reviewPull requestsLeaves review comments and suggested changesMedium, advisory only
Copilot CLITerminalExplains and runs shell and repository tasksMedium, commands need approval
Copilot features by scope and autonomy

Copilot integrates with Visual Studio Code, Visual Studio, JetBrains IDEs, Neovim, Xcode and Eclipse, among others, although new features usually reach Visual Studio Code first. The Model Context Protocol allows agent features to call external tools and data sources configured by the user or the organization.

Plans, limits and administration

Copilot is sold in individual and organizational plans that differ in model access, usage limits and governance controls. Exact prices and quotas change often, so the comparison below describes the structure rather than fixed numbers.

PlanIntended userKey characteristics
FreeIndividual developers trying the toolLimited monthly completions and chat requests
Pro and Pro+Individual professionalsUnlimited completions, larger allowance of premium requests
BusinessOrganizations and teamsCentral policy, seat management, IP indemnity terms
EnterpriseLarge organizations on GitHub Enterprise CloudBroader model access, knowledge features, more premium requests
Copilot plan tiers and their typical differences

Advanced models and agent work consume premium requests, a metered allowance where more capable models cost more units per request. Organization administrators can enable or disable models, set content exclusions that keep chosen files out of Copilot context, and turn on a public code filter that blocks suggestions matching public repository code.

How Copilot compares with other coding assistants

Copilot competes with AI-native editors and agentic tools that take different approaches to the same problem. Its main advantage is deep integration with GitHub issues, pull requests and Actions, while competitors often emphasize editor design or terminal-first autonomy.

ToolPrimary formDistinguishing trait
GitHub CopilotExtension across many IDEs plus GitHub cloud agentNative GitHub workflow integration, multi-model choice
CursorFork of Visual Studio CodeEditor redesigned around AI editing
Claude CodeTerminal-based agentAutonomous multi-step work from the command line
OpenAI CodexCloud and local coding agentTask delegation within the OpenAI ecosystem
TabnineIDE extensionEmphasis on private and self-hosted deployment
Amazon QIDE and console assistantIntegration with AWS services
Copilot and related coding assistants

Copilot should not be confused with Microsoft 365 Copilot, a separate Microsoft product for documents, email and meetings that shares the brand but not the developer focus.

Limitations and responsible use

Copilot output is probabilistic and must be reviewed like code from any contributor. It can produce code that compiles but is subtly wrong, uses deprecated or hallucinated APIs, or introduces security weaknesses such as missing input validation. Studies of productivity report gains on routine tasks, but results vary widely with task type and developer experience.

RiskTypical causeControl
Insecure codePatterns learned from vulnerable examplesCode scanning, security review, tests
Hallucinated APIsMissing or outdated contextCompilation, type checks, documentation lookup
Licensing concernsSuggestions resembling public codePublic code filter and code referencing
Data exposureSensitive files sent as contextContent exclusions and organization policy
OverrelianceAccepting changes without understandingMandatory human review of pull requests
Common risks and how teams control them

The decisive practice is to treat Copilot as a fast but fallible collaborator: keep tests, reviews and security tooling in place, and give agents narrowly scoped tasks with clear acceptance criteria.

In everyday language

GitHub Copilot is like an assistant sitting beside a programmer. While the programmer types, it guesses what comes next and offers to finish the line or the whole function. The programmer can also ask it questions in plain words, such as why a piece of code fails.

Newer versions can do larger jobs on their own, like fixing a reported bug and preparing the change for review. A person still has to check the work, because the assistant can make confident mistakes.

Seen in the real world

A team of eight developers maintains a web application on GitHub with a backlog of small issues, such as missing form validation and outdated dependency warnings. The team lead enables the Business plan, turns on the public code filter and excludes a folder that holds customer configuration files from Copilot context.

Developers use inline completion for routine code and agent mode for multi-file refactoring. For well-defined backlog items, the lead assigns issues to the Copilot coding agent, which works in a cloud environment, runs the existing test suite and opens draft pull requests. Reviewers reject about one in four of these drafts and request changes on several others, often because of missing edge cases. The team clears most small issues faster, while human review and continuous integration catch the errors the agent introduces.