GitHub Copilot

GitHub Copilot is the AI assistant built into the platform where most teams already keep their code. That placement is the whole argument for it — it reads your repositories, your issues, and your pull requests without any extra wiring.

It has grown well beyond suggesting the next line. Copilot now runs chat, an in-editor agent, a cloud agent that works on an issue and opens a pull request, and an automated reviewer that comments on diffs.

This review covers what each mode is for, which editors it reaches, how the tiers differ in ways that actually matter, and where it falls behind dedicated AI editors.

GitHub Copilot Key Details

Four Modes, Four Different Jobs

Copilot is not one feature but several, and they suit very different situations. Knowing which to reach for is most of the skill.

Inline Completion

The original capability: suggestions as you type, accepted with a keystroke. It is best on boilerplate, tests, and code that follows an obvious pattern already present in the file.

This mode asks nothing of you. It is also the one least likely to produce something you have to unpick later.

Copilot Chat And Edits

Chat answers questions about code with your repository as context, which beats a general chatbot for anything project-specific. Copilot Edits applies changes across several files from a single instruction.

Use Chat to understand unfamiliar code, and Edits when you know the change you want but not every file it touches.

Agent Mode

Agent mode works autonomously inside the editor — planning, editing across files, running commands, and reacting to failures. It suits a scoped task you intend to review immediately.

As with any agent, a clear success condition matters more than a detailed prompt. Give it a test to pass and it will keep working toward it.

The Cloud Coding Agent

Assign an issue to Copilot and it works on a cloud machine, then opens a pull request for review. Nothing runs on your laptop and you are not watching it work.

This fits well-specified, low-risk tasks — dependency bumps, small bug fixes, mechanical refactors. It fits ambiguous product work badly.

Automated Review On Pull Requests

Copilot can review a pull request and leave comments before a human opens it. In practice it reliably catches the unglamorous things: missing null checks, unhandled errors, tests that do not assert what they claim.

It is weaker on architectural judgement and on whether a change is the right idea at all — the questions experienced reviewers are actually needed for.

Used as a first pass it saves reviewers real time. Used as an approval gate it will wave through decisions no model should be making.

Model Choice And MCP Extensions

Copilot exposes a catalogue of models rather than a single one, spanning OpenAI and Anthropic families, with faster and cheaper options alongside heavier ones. You switch per task, which matters because a quick completion and a deep refactor want different models.

Model Context Protocol support lets Copilot reach external tools and data sources, with allow lists so an organisation controls which MCP servers are reachable.

That combination — model choice plus governed extensions — is what makes Copilot viable in companies that cannot let a coding assistant reach arbitrary services.

It Runs Almost Everywhere You Do

Editor coverage is broader than any competing assistant, which matters for teams that are not standardised on one IDE.

The reach beyond editors is the part people underuse: reviewing on github.com, asking a question from GitHub Mobile, or driving it from the terminal.

• VS Code, Visual Studio, JetBrains IDEs, Xcode, Neovim, and Eclipse
• github.com and GitHub Mobile
• GitHub CLI and the dedicated Copilot CLI
• A desktop app, plus Raycast for quick access
• Copilot Spaces for curating the context Copilot draws on

Reading The Tier Ladder Honestly

There are six named tiers — Free, Pro, Pro+, Max, Business, and Enterprise — and the differences that matter are not really about volume.

Audit logs start at Pro+. Access control and budget control arrive with Business. IP indemnity, the duplication detection filter, and the Data Protection Agreement supporting GDPR are the enterprise-facing items that usually decide procurement, not the number of requests.

If you are evaluating for a company rather than yourself, work down from the governance features you need rather than up from the cheapest tier.

Copilot Spaces And Curated Context

Copilot Spaces let you assemble the material Copilot should reason over — specific repositories, documentation, and notes — instead of hoping it infers the right context from whatever file is open.

This matters most in large organisations where the answer to "how do we do this here" lives in a design doc rather than in code. A Space pointed at the right sources turns Copilot from a generic assistant into one that knows your conventions.

It is the closest equivalent to a rules file in dedicated AI editors, and teams that set one up get markedly more relevant answers than teams that do not.

Where Copilot Gives Ground

Its inline completion is good but no longer the best available — dedicated AI editors have pulled ahead on multi-line prediction and on following a refactor through a file.

Agent output on large, unusual codebases has the same failure mode as every competitor: confident code that looks right and is not. Review discipline is not optional.

The free tier is a genuine trial rather than a workable plan, and quality varies by language, with mainstream ecosystems served noticeably better than niche ones.

Is Copilot The Right Default?

For teams already living on GitHub, Copilot is the path of least resistance and a genuinely strong tool. Context comes free, governance is mature, and the coverage across editors and surfaces is unmatched.

Choose it when your work already flows through GitHub issues and pull requests, when your team uses mixed IDEs, or when IP indemnity and audit logs are requirements. Look at a dedicated AI editor if raw autocomplete quality and deep agent work in one codebase are what you care about most.

Check github.com for current plans, since the split between tiers moves and the governance features are the part worth confirming before rollout.