Welcome to the first post in my series on getting the most out of GitHub Copilot in the terminal. We'll kick things off with one of the most important things to understand: the different modes Copilot CLI operates in, and when to reach for each one.
A quick intro to GitHub Copilot CLI
GitHub Copilot CLI is a terminal-native coding agent — not just a chat wrapper. It can plan complex tasks, edit files, run tests, and iterate autonomously, all without leaving your terminal. But to get the most out of it, you need to understand how to control how much autonomy you give it at any point in time. That's exactly what the different modes are for.
You cycle through the main modes using Shift+Tab. A mode indicator in the CLI's footer tells you which one you're currently in.
The three main modes
1. Standard Mode — The default
When you launch copilot, you start in standard (interactive) mode. This is the classic back-and-forth: you submit a prompt, Copilot responds or takes an action, and then waits for your next instruction. It will ask for your approval before executing any tool or shell command that requires permission.
This mode gives you the most control and is the right starting point for most tasks — especially exploratory ones where you want to stay hands-on and guide the work step by step.
Best for: open-ended exploration, iterative development, tasks where you want to review each step before moving on.
2. Plan Mode — Think before you build
Press Shift+Tab to cycle into plan mode. Instead of immediately starting to write code or execute commands, Copilot shifts into a collaborative planning phase. It asks you clarifying questions, confirms its understanding of scope and requirements, and builds a structured implementation plan before touching a single file.
Once you've reviewed and approved the plan — which appears in a dedicated panel in the UI — you can tell Copilot to start implementing. You can even hand off directly to autopilot mode from there with "Accept plan and build on autopilot."
Plan mode is particularly valuable for complex, multi-step tasks. Catching a misunderstanding at the planning stage is far cheaper than untangling a half-implemented feature.
Best for: new features, refactors, anything where getting the approach right upfront matters.
Pro tip: If you see that Copilot is going off rails, you can always interrupt and provide some input or feedback. Copilot will pick this up and change the plan accordingly.
3. Autopilot Mode — Hands-off execution
Keep pressing Shift+Tab to reach autopilot mode. In this mode, Copilot works autonomously through a task without pausing for your input at each step. It continues executing — editing files, running commands, calling tools — until it determines the task is complete, hits an error it can't resolve, or you press Ctrl+C to stop it.
Autopilot mode works best with explicit tool permissions. You can launch the CLI with --allow-all to grant full permissions upfront (or through the /allow-all slash command), or use --max-autopilot-continues to cap how many steps the agent can take before stopping — a good safety net for tasks you're less certain about.
Best for: well-defined tasks you trust Copilot to handle end-to-end — writing tests, fixing CI failures, applying a well-understood refactor across multiple files.
Pro tip: Autopilot is not ideal for open-ended or ambiguous tasks. If the goal isn't crystal clear, you risk getting a pile of changes that don't quite hit the mark. Use plan mode first to align on the approach, then hand off to autopilot.
Shell Mode — Bypassing the agent entirely
Shell mode is a bit different from the three above — it's not part of the Shift+Tab cycle. Instead, you access it by prefixing any prompt with !. This executes the command directly in your shell without making a call to the model at all.
! git status
! npm test
! ls -la src/This is handy when you're mid-conversation with Copilot and want to quickly check something in your environment — run a test, inspect a file, check git status — without starting a new terminal or breaking your flow. Think of it as a built-in escape hatch to your shell.
Best for: quick environment checks, running commands mid-session, avoiding context switches to another terminal window.
Pro tip: Shell mode history navigation filters by prefix. Type !git and press the up arrow, and you'll cycle only through previous git commands — making it fast to find and reuse recent shell commands.
Putting it all together
A natural workflow for bigger tasks looks like this: start in plan mode to get aligned on the approach, then Shift+Tab through to autopilot to let Copilot run with it. Drop back into standard mode when you want to steer in real time, and use shell mode whenever you need to quickly check something in your environment without breaking your flow.
| Situation | Mode |
| Exploring a codebase or asking questions | Standard |
| Starting a complex or multi-step task | Plan |
| Executing a well-defined task end-to-end | Autopilot |
| Running a quick shell command mid-session | Shell (! prefix) |
Wrapping up
Understanding these modes is the foundation for using Copilot CLI effectively. The right mode at the right time means you stay in control without becoming a bottleneck in your own workflow.
In the next post, we'll look at session management.
More information
GitHub Copilot CLI - GitHub Docs
Allowing GitHub Copilot CLI to work autonomously - GitHub Docs