GitHub Copilot Keyboard Shortcuts
GitHub Copilot lives as an extension inside an existing editor rather than being an editor of its own, and its keyboard model reflects that — Copilot adds a specific layer of suggestion-cycling, partial-acceptance, and chat-invocation shortcuts on top of whatever host editor you're already using, most commonly VS Code, without touching that editor's own navigation or general editing shortcuts at all. The inline suggestion behavior is Copilot's oldest and still most-used feature: as you type, ghost-text completions appear inline, and the keyboard choices around them are more granular than a simple accept-or-reject binary — you can accept an entire multi-line suggestion at once, accept just the next word of it if only part looks right, or cycle through alternative suggestions when the first one shown isn't the best fit. Copilot Chat, added later, brought a second, more conversational layer with its own distinct set of bindings for opening the chat panel, triggering an inline chat directly in the editor buffer, and quick actions like explaining or fixing selected code, layered alongside rather than replacing the original inline-suggestion mechanics. Because Copilot is specifically an extension riding on top of a host editor's existing keybinding system, some of its default shortcuts can collide with bindings the host editor or other installed extensions already claim, particularly in VS Code where a crowded extension list is common — checking Copilot's own keybinding entries under the GitHub Copilot category in your editor's keyboard shortcuts settings is worth doing once if a binding doesn't seem to fire.
Inline Suggestions
| Action | Windows | Mac | Description |
|---|---|---|---|
| Accept the full inline suggestion | Tab | Tab | Commits the entire ghost-text suggestion currently shown, inserting it as real code at the cursor — the default, fastest path when the full suggestion already looks correct as shown. |
| Accept the next word of a suggestion | Ctrl+Right Arrow | Cmd+Right Arrow | Commits just the next word of the current ghost-text suggestion rather than the entire line or block, letting you take the part you agree with and keep typing your own continuation for the rest, useful when a suggestion starts correctly but you're not confident it stays correct for its full length. |
| Dismiss the current suggestion | Esc | Esc | Clears the currently shown ghost-text suggestion without inserting any of it, returning to plain typing, the direct counterpart to accepting. |
| Cycle to the next alternative suggestion | Alt+] | Option+] | Copilot often has more than one candidate completion available at a given point; this cycles forward to the next alternative without accepting anything, useful when the first suggestion shown isn't the best fit but a genuinely different approach might be available rather than a minor variation. |
| Cycle to the previous alternative suggestion | Alt+[ | Option+[ | Cycles backward through alternative completions, the reverse companion to cycling forward, useful for returning to a previously shown suggestion you passed over too quickly. |
| Manually trigger a suggestion | Alt+\ | Option+\ | Forces Copilot to generate a suggestion at the current cursor position on demand, useful when a suggestion hasn't appeared automatically or after dismissing one and wanting a fresh attempt rather than continuing to type and wait. |
| Open suggestions in a separate panel | Ctrl+Enter | Cmd+Enter | Opens a dedicated panel showing every full candidate completion Copilot currently has for that spot laid out side by side, which is a genuinely different view than the single inline ghost-text suggestion, letting you compare several distinct approaches at a glance instead of stepping forward and backward through them individually. |
| Accept only the next line of a suggestion | Ctrl+Down Arrow (varies by version) | Cmd+Down Arrow (varies by version) | A finer-grained middle ground between accepting the whole suggestion with Tab and accepting just one word with the word-acceptance shortcut, taking exactly the next line of a multi-line suggestion so you can evaluate the remaining lines separately rather than committing to the entire block at once. |
Copilot Chat
| Action | Windows | Mac | Description |
|---|---|---|---|
| Open Copilot Chat panel | Ctrl+Alt+I | Cmd+Ctrl+I | Opens the Copilot Chat sidebar for a conversational interaction — asking questions about code, requesting an explanation, or describing a change in more depth than a single inline suggestion covers. |
| Start inline chat at the cursor | Ctrl+I | Cmd+I | Pops open a small chat box right in the editor buffer, anchored to wherever your cursor or current selection is, so a quick request stays inline instead of pulling your attention away to a separate sidebar panel for something small. |
| Open Quick Chat | Ctrl+Shift+Alt+L | Cmd+Shift+Option+L | Opens a lightweight, transient chat input for a single quick question without committing to opening or navigating the full persistent Chat sidebar panel. |
Frequently Asked Questions
What's the practical difference between accepting a full suggestion (Tab) and accepting word-by-word (Ctrl/Cmd+Right)?
Tab commits everything shown in the current ghost-text suggestion in one action, appropriate when the whole thing already looks right. Accepting word-by-word takes only the next word and leaves the rest of the suggestion still pending, letting you effectively co-write a line with Copilot — taking the parts that match what you intended and typing your own continuation the moment the suggestion diverges from what you actually want, rather than committing to the entire block or rejecting it outright.
Why does cycling with Alt+]/Alt+[ sometimes show only minor variations instead of a genuinely different approach?
The number and diversity of alternative completions Copilot generates depends on the surrounding code context and how much genuine ambiguity exists at that point — a well-constrained context with an obvious next step tends to produce similar alternatives because there genuinely isn't much room for a different correct answer, while a more open-ended point in the code (the start of a new function with a vague name, for instance) tends to produce more varied candidates. If cycling isn't surfacing anything useful, opening the full suggestions panel (Ctrl/Cmd+Enter) shows more candidates at once and can reveal a wider spread than cycling one at a time.
Do these Copilot shortcuts work the same way in JetBrains IDEs or Visual Studio as they do in VS Code?
The core concepts — accept, dismiss, cycle alternatives, open chat — exist across Copilot's supported editors, but the exact key combinations aren't guaranteed to be identical, since each host editor has its own pre-existing keybinding conventions that Copilot's extension has to fit into without excessive collision. VS Code is the most commonly documented and most actively developed target for Copilot's keybindings, so always verify the exact combination inside your specific editor's own keyboard shortcuts settings rather than assuming a VS Code binding transfers unchanged.
Why did my Tab key stop accepting Copilot suggestions after I installed another extension?
This is a genuine, fairly common Copilot gotcha — Tab is a heavily contested key in any editor with several installed extensions, and a snippet-expansion extension, another AI tool, or even certain language-specific extensions can register a competing Tab binding that takes priority depending on install order and context. Checking your editor's keyboard shortcuts settings for the Copilot-specific 'accept inline suggestion' command and looking for a conflict listed there is the fastest way to diagnose and reassign it.
Is there a way to see several of Copilot's candidate suggestions laid out together, instead of only ever seeing one at a time inline?
Yes — Ctrl+Enter (Cmd+Enter on Mac) opens the dedicated completions panel, which lays out multiple full candidates at once rather than showing only whichever single suggestion is currently active as inline ghost text. It's generally the faster route once you already suspect the first suggestion isn't the strongest option and want a broader view before picking, rather than repeatedly tapping the cycle key and holding each candidate in your head as you go.
What's the difference between inline chat (Ctrl/Cmd+I) and the full Copilot Chat panel?
Inline chat opens a compact prompt directly inside the editor buffer at your cursor or selection, suited to a quick, contained request without leaving your place in the code. The Chat panel is a persistent sidebar better suited to longer conversations, questions that need more back-and-forth, or requests where you want to keep scrolling back through prior exchanges in the same session rather than a single transient inline prompt.
Does dismissing a suggestion with Esc tell Copilot not to suggest something similar again at that spot?
No — dismissing just clears what's currently shown; it isn't a negative training signal that permanently steers future suggestions away from similar completions at that location. If you retype into roughly the same context, a similar suggestion can reappear, since Copilot is generating fresh based on the surrounding code each time rather than remembering that you previously rejected something comparable.
Can Copilot Chat see my whole codebase, or only the file I currently have open?
It depends on context and configuration — Copilot Chat can incorporate more than just the single open file, including other open editor tabs and, depending on setup and workspace indexing, broader repository context, but it isn't guaranteed to have full unprompted awareness of every file in a large codebase the way you might assume. Explicitly referencing a specific file or being precise about what you're asking about tends to produce more grounded answers than assuming Chat has already read everything relevant on its own.
When does accepting line-by-line actually beat accepting the full suggestion or just the next word?
Word-by-word acceptance is the right granularity when a suggestion's very next token is questionable but the overall direction still seems reasonable; full acceptance is right when the whole block already looks correct. Line-level acceptance sits between those two and earns its place specifically on multi-line suggestions where the first line or two are clearly right but you want to see how the following lines render before deciding on them too, rather than either committing to everything at once or slowing down to word-by-word for a suggestion that's mostly fine.
Is it worth memorizing all of Copilot's cycling and partial-accept shortcuts, or is Tab-and-Esc enough for most people?
Tab and Esc alone cover a large share of real usage and are a perfectly reasonable starting point. The cycling and partial-accept shortcuts earn their keep specifically once you notice yourself frequently rejecting a whole suggestion just because the tail end was wrong while the beginning was fine, or dismissing and retyping when a different candidate would likely have been closer — at that point, the extra few keystrokes to learn typically save more time than they cost within the first week of genuinely using them.