Completions vs chat - two ways in

With Copilot installed and reading your workspace, one distinction matters early: inline completions and chat are not interchangeable, and they are not good at the same things. A common early frustration with Copilot comes from using one where the other belongs.

Completions: the autocomplete that finishes your thought

Inline completions are the grey ghost text. You are typing, and Copilot offers the rest of the line - or the rest of the block - which you accept with a keypress or ignore by typing past it. It reads the file around your cursor and the shape of what you have started, and it is fast: no prompt, no waiting, no conversation.

What completions are good at is continuation. You wrote a function signature and it drafts the body. You started a test and it fills in the assertions. You are ten iterations into a repetitive block and it finishes the pattern. You stay in the driver’s seat, typing, and Copilot keeps pace half a step ahead.

What completions are not good at is anything you would have to explain. They are not built to take an instruction, to reason across files you do not have open, or to be told “do it our team’s way.” The moment you find yourself wishing you could tell the suggestion what you want, you have reached the edge of completions - and chat is the tool you actually want.

Chat: the colleague you brief

The Chat view is a conversation. You describe what you want in words; Copilot proposes - an explanation, a diff, a multi-step change - and you review. It reads far beyond your cursor: open files, files it decides are relevant, and later in this course the instruction files you have written and the tools you have connected.

Chat is the surface this course is about, because it is where Copilot stops being autocomplete and becomes an agent - something you delegate to, not just type alongside. Inside chat there is a second choice waiting: the agents dropdown, which selects how much latitude Copilot has to act on what you asked - from read-only answers to a fully autonomous run. That choice is a later chapter’s subject in full. For now, the split to internalize is simpler:

• Reaching for a continuation of what you are typing? Completions. Stay in the file, let the ghost text help.
• Have something to explain - a bug to describe, a change to request, a question about unfamiliar code? Chat. Open the panel and brief it like a colleague.

Why the split matters on code you didn’t write

The distinction bites hardest on inherited code, which is exactly the situation this course runs on. The fastest way to get oriented in an unfamiliar repo is not to start typing and hope completions catch your drift - it is to ask. Chat can read the code and explain it back, trace where a value comes from, or summarize what a module does, before you change a single line. Completions cannot do any of that, because there is nothing to continue: you do not know enough to start the line.

That is the situation with the course scenario’s first task: the inherited order service returns its “recent orders” list oldest-first when the UI expects newest-first - a bug in unfamiliar code that you can describe but could not confidently fix by typing. So it is a chat job. Next: your first reviewed change.