Why This Matters

Most beginners discover one surface — usually inline completions — and use it for everything. That works for a week or two, then they hit a wall: "why can't Copilot see my other file?", "can I use this from the terminal?", "why is the chat giving me generic answers?". The wall is always the same: they're using the wrong surface for the task.

Knowing the eight surfaces is like knowing the eight tools in a chef's knife roll. You don't need all eight for every meal — but you need to know which one to grab when.

Concept Explained

A "surface" is a place where Copilot appears and where you interact with it. Each surface has its own context model, latency profile, and affordances. Some are interactive (you type, it responds); one is autonomous (you delegate, it works in the background); two are programmatic (you call them via code).

The eight surfaces, in order of typical beginner exposure, are:

1. Inline completions — ghost-text suggestions inside your editor's text buffer.
2. Copilot Chat — a conversational side panel in your editor and on github.com.
3. Slash commands — short, scoped instructions prefixed with / (e.g. /explain, /tests).
4. The copilot CLI — a standalone terminal command (replaced the deprecated gh copilot extension in October 2025).
5. Copilot on GitHub.com — chat, pull-request summaries, code review, and issue triage in the browser.
6. Copilot Spaces — scoped context containers (GA September 2025) that group repos, docs, and files.
7. The Copilot coding agent — an autonomous developer (GA September 2025) that you assign an issue to and that works in a branch.
8. Copilot Extensions — @-participants that call external services (e.g. @azure, @github).

There is also a REST API surface, but it is administrative (seat management, usage metrics, policy), not a coding assistant. We list it as the "eighth-plus" surface and cover it in the Professional phase.

How It Works

All eight surfaces share the same underlying model fabric — they differ in context assembly and interaction shape:

• Inline completions fire on every keystroke (after a debounce), with context = current file + recent edits. Latency budget: ~300ms before the suggestion feels laggy.
• Chat fires on each message, with context = current selection + attached files + chat history. Latency budget: a few seconds for the first token, streaming thereafter.
• Slash commands are pre-baked prompts that ship in Chat and the CLI. They add structure ("explain", "write tests", "fix this") without you typing the full instruction.
• The CLI fires on each command, with context = your current shell session + the files you point it at. It can edit files directly, which the editor's Chat cannot do without your confirmation.
• GitHub.com chat fires on each message, with context = the repo or issue you're viewing in the browser.
• Spaces pre-assemble a context bundle (repos + docs + files) that persists across conversations, so you don't have to re-attach context every time.
• The coding agent runs autonomously. You assign it an issue; it plans, edits files across the repo, runs tests if available, and opens a PR. Latency budget: minutes to hours.
• Extensions are triggered by typing @ + a participant name in Chat. They fetch real-time data from an external service and inject it into the model's context.

The mental shortcut: surfaces on the left of this list are interactive and fast; surfaces on the right are batched, scoped, or autonomous. Pick accordingly.

Step-by-Step Tutorial

1. Map each surface to its primary use

For each surface, decide what it is best at. A reasonable starting point:

• Inline completions — finishing the line or function you're already writing.
• Chat — explaining code, refactoring, exploring alternatives.
• Slash commands — the four common chores: explain, fix, tests, doc.
• CLI — driving edits from the terminal, especially for ops/infra tasks.
• GitHub.com chat — answering repo-level questions without cloning.
• Spaces — keeping multi-repo or docs+code context persistent.
• Coding agent — delegated, multi-file tasks you'd otherwise queue for a junior.
• Extensions — bringing live external data (deployments, alerts, tickets) into the conversation.

2. Decide interactive vs autonomous

Surfaces 1–6 are interactive: you type, it responds. Surface 7 (coding agent) is autonomous: you delegate, it works while you do something else. Knowing this changes how you phrase your request. Interactive prompts should be short and incremental; agent prompts should be complete specifications ("Implement issue #142. Tests must pass. Don't touch auth/*.").

3. Check plan availability for each surface

Free and Pro plans include inline completions, Chat, slash commands, the CLI, GitHub.com chat, and (since GA in September 2025) the coding agent. Copilot Spaces is available on Pro and higher. Copilot Extensions work on Pro and higher. The REST API for usage metrics and seat management requires Business or Enterprise.

4. Pick the right surface for five common tasks

Test yourself against these five scenarios. (Answers in the next section.)

1. You're writing a function and want the body suggested as you type.
2. You inherited a 5,000-line file and want a one-paragraph summary.
3. You're in a terminal and need to refactor three Python files.
4. You want Copilot to answer "which repos use the deprecated v1 API?" across 12 repos.
5. You want Copilot to implement a GitHub issue end-to-end while you review a different PR.

Real-World Example

A platform team at a fintech adopted Copilot in early 2026. Their first month was chaotic: every developer used inline completions for everything, including multi-file refactors ("why does Copilot keep forgetting the type definitions?"). After a one-hour workshop on surfaces, the team adopted a simple rule: if a task touches one file, use inline or Chat; if it touches multiple files, use @workspace or the CLI; if it's a fully specified chore, delegate to the coding agent; if it requires external context (alerts, tickets, dashboards), use an Extension. Within two weeks, Copilot-induced bugs dropped by 60% and developer satisfaction scores doubled. The product hadn't changed — only the surface selection had.

Example Prompts / Commands / Code

1. Inline completions
2. Chat with the file open (use @workspace if the file references others)
3. The `copilot` CLI (multi-file edits + diff review from terminal)
4. Copilot Spaces (curate the 12 repos into a Space, then ask)
5. The coding agent (assign the issue, work on something else, review the PR)

# From a repo root, run:
copilot "Replace all usages of the deprecated `getUser(id)` API with `fetchUser(id)` across src/. Show me a diff before applying."

# Copilot CLI will propose changes file-by-file, ask for confirmation, then apply.

Common Mistakes

• Using inline completions for multi-file refactors — it has no cross-file context by default.
• Using Chat when the CLI would be faster — Chat can't run commands; the CLI can.
• Using the coding agent for a 30-second task — agent sessions take minutes to spin up; only delegate multi-file chores.
• Assuming GitHub.com chat has the same context as your IDE — it doesn't see your local working tree, only what's pushed.
• Forgetting that Spaces persist — context you added last week is still there. Prune them periodically.
• Treating Extensions as toys — they can call real services with real side effects. Audit their scopes before installing.

Best Practices

• Match the surface to the task's scope: 1 file → inline/Chat; many files → CLI or @workspace; multi-repo → Spaces; delegated → agent.
• Keep one surface as your default (Chat for most people) and reach for the others deliberately.
• When you switch surfaces, briefly tell yourself why — the act of naming prevents autopilot.
• Audit installed Extensions monthly. Uninstall any you haven't used in 30 days.
• Use the CLI for ops/infra work where you're already in a terminal; the editor would just slow you down.
• When delegating to the agent, write the issue as a complete spec — see PR-16 for the delegation runbook.

Troubleshooting

Practical Exercise

Professional Challenge

Frequently Asked Questions

Further Reading

• Copilot CLI product page
• Copilot Spaces announcement
• Copilot coding agent GA
• Copilot Extensions overview

Official References

• GitHub Copilot — features overview
• Copilot Spaces GA changelog
• Copilot coding agent GA discussion
• Copilot CLI documentation

Related lessons: BE-01, BE-04, IN-17