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.
| Feature | Where it runs | What it does | Autonomy level |
|---|---|---|---|
| Code completion | Editor | Suggests the next lines as the user types | Low, user accepts each suggestion |
| Copilot Chat | Editor, GitHub website, mobile | Answers questions, explains and edits code | Low to medium |
| Agent mode | Editor | Plans multi-file edits, runs commands, iterates on errors | Medium, user supervises in session |
| Coding agent | GitHub cloud environment | Works on an assigned issue and opens a pull request | High, reviewed through the pull request |
| Code review | Pull requests | Leaves review comments and suggested changes | Medium, advisory only |
| Copilot CLI | Terminal | Explains and runs shell and repository tasks | Medium, commands need approval |
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.
| Plan | Intended user | Key characteristics |
|---|---|---|
| Free | Individual developers trying the tool | Limited monthly completions and chat requests |
| Pro and Pro+ | Individual professionals | Unlimited completions, larger allowance of premium requests |
| Business | Organizations and teams | Central policy, seat management, IP indemnity terms |
| Enterprise | Large organizations on GitHub Enterprise Cloud | Broader model access, knowledge features, more premium requests |
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.
| Tool | Primary form | Distinguishing trait |
|---|---|---|
| GitHub Copilot | Extension across many IDEs plus GitHub cloud agent | Native GitHub workflow integration, multi-model choice |
| Cursor | Fork of Visual Studio Code | Editor redesigned around AI editing |
| Claude Code | Terminal-based agent | Autonomous multi-step work from the command line |
| OpenAI Codex | Cloud and local coding agent | Task delegation within the OpenAI ecosystem |
| Tabnine | IDE extension | Emphasis on private and self-hosted deployment |
| Amazon Q | IDE and console assistant | Integration with AWS services |
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.
| Risk | Typical cause | Control |
|---|---|---|
| Insecure code | Patterns learned from vulnerable examples | Code scanning, security review, tests |
| Hallucinated APIs | Missing or outdated context | Compilation, type checks, documentation lookup |
| Licensing concerns | Suggestions resembling public code | Public code filter and code referencing |
| Data exposure | Sensitive files sent as context | Content exclusions and organization policy |
| Overreliance | Accepting changes without understanding | Mandatory human review of pull requests |
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.