GitHub Copilot has been generally available since June 2022, which in AI terms makes it practically a heritage product. It arrived as a technical preview in 2021, powered by OpenAI’s Codex model, and plenty of people assumed it was a party trick that would collapse the moment it met a real codebase. Instead, it became the default. GitHub says more than 15 million developers have tried it, and somewhere north of a million of them pay for it every month.
The origin story matters less than what the thing has turned into. Copilot is no longer one model bolted onto autocomplete. It’s a suite: inline suggestions, a chat panel, automated pull request review, and an agent mode that can plan and carry out changes across multiple files without you typing the code yourself. Knowing which piece you’re actually using is the difference between a real speed-up and a slow drip of subtle bugs.
What GitHub Copilot actually does
Under the hood, it’s a large language model hooked into your editor with your open files, project structure, and sometimes your whole repository as context. Give it a function signature and a comment, and it proposes a body. Keep typing and it adjusts. It’s excellent at boilerplate: argument parsers, config loaders, test scaffolding, date formatting, the twentieth React component that looks like the other nineteen. It’s noticeably worse at genuinely novel design work, which is annoyingly the opposite of where most engineers want to be rescued.
Inline completions
This is the feature that made Copilot famous: grey ghost text appearing as you type, accepted with Tab. It reads surrounding code, and on paid plans it can pull in other files that look relevant. Most people report it’s right often enough that accepting becomes muscle memory, which is exactly the risk. You stop reading carefully.
Chat and slash commands
Ctrl+I or Cmd+I opens inline chat in VS Code and JetBrains IDEs, and there’s a persistent side panel too. Useful commands include /explain to walk through a gnarly regex, /fix to interpret an error message, /tests to generate a first pass at a unit test, and @workspace to ask questions that span the whole repo. The chat is where Copilot earns its keep for anyone maintaining unfamiliar code, and it’s a big reason some developers keep a separate subscription to a general-purpose assistant as well, simply to argue a problem through.
Agent mode and code review
Agent mode, rolled out through 2024 and 2025, lets Copilot make edits across several files, run terminal commands, and iterate when tests fail. Separately, Copilot can review a pull request and leave inline comments. Both features are genuinely useful and both demand supervision. An agent that confidently refactors twelve files is also an agent that can confidently break twelve files.
What you’ll pay in 2025
- Copilot Free: 2,000 code completions and 50 chat messages a month, no card required.
- Copilot Pro: $10 per month, unlimited completions, access to premium requests and a choice of models including GPT-4o, Claude Sonnet, and Gemini.
- Copilot Pro+: $39 per month, aimed at heavy users who burn through premium requests fast.
- Copilot Business: $19 per user per month, adding policy controls, audit logs, IP indemnity, and a commitment not to train on your code.
- Copilot Enterprise: $39 per user per month, with codebase indexing, documentation search, and tighter GitHub integration.
Verified students, teachers, and maintainers of popular open-source projects get Pro at no cost. For a solo developer, the honest calculation is whether it saves you an hour a month. It usually does.
Where it falls over
The failure modes are consistent and worth naming. Copilot invents package names that don’t exist, which researchers have flagged as an actual supply-chain risk when attackers register the imaginary names. It confidently calls methods with the wrong number of arguments on libraries it half-remembers. It writes tests that assert what the code does rather than what it should do, so a bug gets baked into the test suite. It also mirrors whatever patterns are already in your file, which means a messy codebase quietly trains its own assistant to produce more mess.
There’s also the productivity question. GitHub’s own study found developers completed a task roughly 55% faster with Copilot. Independent studies have been far less flattering, with at least one finding no meaningful speed gain and more code produced with more review overhead. The realistic reading: it helps most on greenfield work and unfamiliar languages, and helps least when you already know the codebase cold.
How it compares to everything else
The competition has caught up substantially, and the wider field of AI tools that are actually worth your time has become genuinely crowded. Three rivals come up most often.
Codeium built its following on being free for individual developers, and it has grown from a fast autocomplete into a credible full assistant with chat and search across a repo. If cost is the deciding factor, it’s the obvious first stop.
Amazon CodeWhisperer makes the most sense if your stack lives on AWS. It knows the SDKs, it flags security issues, and it has a reference tracker that tells you when a suggestion resembles public training data. Outside the AWS ecosystem, its pull is weaker.
Continue.dev takes the opposite approach: open source, and you choose the model behind it, including a local one. For anyone with strict data rules, that flexibility is often the whole point.
Chain-of-thought behaviour is improving fast across all of these, so the gap narrows every few months. What differentiates them is really the ecosystem: how well the tool indexes your repository, how it handles your privacy requirements, and whether your team can administer it without a fight.
Habits that separate useful from useless
- Write the comment before the code. A precise docstring in, a decent function out.
- Keep files small. Copilot’s context window is generous but not infinite, and relevance drops off a cliff in a 4,000-line file.
- Treat every accepted suggestion as a code review you skipped. Read it once before you move on.
- Use @workspace for architecture questions and plain chat for syntax questions. They behave differently.
- Turn on content exclusions for secrets, config, and anything under a compliance umbrella.
- Ask it to write the test first when the logic is fiddly. It’s better at describing intent than inventing it.
The questions teams should ask before rolling it out
The individual experience is straightforward. The organisational one is where Copilot gets complicated. Business and Enterprise customers get IP indemnity, meaning GitHub will defend you if a generated snippet turns out to be someone else’s copyrighted code, but that protection comes with conditions: you need the duplication detection filter on, and you need to have applied the right policies. Public code matching filters are not on by default in every configuration.
Then there’s the quiet cultural change. When completions are cheap, code review queues grow, and reviewers who were already stretched become the bottleneck. Several engineering leads have described this as the real cost of adoption: not the licence fee, but the extra pull requests nobody has time to read properly. Some teams respond by tightening their definition of done. Others find that once Copilot writes tests and documentation, the review load evens out.
There’s no clean verdict here, and anyone selling you one is guessing. The teams getting the most out of GitHub Copilot treat it as a fast junior developer with superb recall and no judgement whatsoever, which is a useful thing to have on a team as long as somebody is still checking the work.