Here's the tell that you picked the wrong Copilot mode: you asked a question and got a pull request, or you asked for a change and got a lecture. Both are Copilot doing exactly what the mode told it to do. The friction isn't the model — it's the mismatch between how much autonomy you handed over and how much the task actually needed.
Most developers I watch pick a mode by habit, not by task. They find one that works, pin it, and drive everything through it. That's how you end up letting an autonomous agent loose to answer "what's the difference between Task and ValueTask." The modes aren't ranked. They're different tools for different kinds of stuck.
The real axis is control, not capability
It's tempting to think of Agent mode as "Ask mode but more powerful." It isn't. What separates them is how much of the loop you keep your hands on.
Ask mode is conversational. Copilot doesn't touch your workspace files — it answers based on the context you give it, in the current file or selection. It produces suggestions and explanations, nothing more. Nothing changes on disk until you copy something out yourself. It's fast because it isn't planning, editing, or running anything.
Agent mode hands Copilot the keys. It reasons across your actual project files, plans multi-step work, runs commands, makes edits, and iterates until the task looks done — applying changes automatically and only surfacing genuinely risky commands for your approval before they run. That's enormous leverage and a real surrender of control. It may take longer, and it will touch files you didn't name.
Put plainly:
|
Ask mode |
Agent mode |
| Touches your files |
No |
Yes, automatically |
| Scope |
Current file / selection |
Whole workspace |
| Runs commands |
No |
Yes |
| Best for |
Learning, deciding |
Executing, refactoring |
| You stay in the loop |
Fully |
At checkpoints |
Reach for Ask mode when the blocker is knowledge
Ask mode is the lowest-friction way to get unstuck when what's standing in your way is understanding, not typing. You're not asking Copilot to do something — you're asking it to tell you something so you can decide.
Good Ask-mode prompts in a .NET codebase look like:
- "Explain the difference between
Task and ValueTask in C# and when each one is worth it."
- "What's the best way to implement structured logging in a .NET 8 Web API?"
- "Walk me through what this
IAsyncEnumerable method is actually doing."
Notice these are decisions and explanations, not edits. You'd use the answer to write the code yourself, or to choose an approach before you commit to it. The moment you'd be copy-pasting Copilot's reply straight into a file across three classes, Ask mode has stopped being the efficient choice.
Reach for Agent mode when the work is mechanical but spread out
Agent mode earns its keep when the task is clear, tedious, and touches more than the file in front of you. The value isn't cleverness — it's that it can hold the whole workspace in context and keep the pieces consistent while it works.
Where it pays off in .NET:
- "Refactor the selected method to use async/await" — and let it fix the callers it breaks.
- "Generate unit tests for
MyService in the current project," wiring up the fakes and matching the existing test conventions.
- "Rename this namespace across the solution and update every
using."
- "Find where we still call the sync
HttpClient overloads and migrate them."
These share a shape: you already know what "done" means, and the labor is spread across files. That's precisely the work you don't want to babysit line by line — and precisely where a conversational back-and-forth would waste your afternoon.
The heuristic from Microsoft's own .NET blog is worth internalizing: when in doubt, start with Ask mode. If you realize the request needs context from your real files or needs edits made, switch to Agent mode. Escalate into autonomy; don't default into it.
Don't forget the middle setting
Ask and Agent are the two ends, but there's a deliberate middle: Edit mode. It takes natural-language instructions, changes the files you've selected, and shows you a diff to approve before anything lands. It's the surgical option — "add error handling here," "convert this to a primary constructor" — with no autonomous wandering into code you didn't point at.
If Agent mode feels like too much rope for a small change in a brownfield service you don't fully trust, Edit mode is the answer: same instruction, tighter blast radius, a diff you sign off on.
The switch is the skill
The developers getting the most out of Copilot aren't the ones who found the "best" mode. They're the ones who move between modes inside a single task without thinking about it.
A realistic session: you're staring at a slow endpoint. You open Ask mode — "why would this LINQ query cause multiple database round-trips?" — and it explains the N+1. Now you know the fix, so you switch to Agent mode — "rewrite this repository method to load the related entities in one query and update the tests." It edits the method, adjusts the call site, reruns the tests. You review the diff and ship.
That's the whole game. Ask when you're deciding, edit when you're being surgical, and let the agent run when the answer is known and the work is spread out.
The concrete takeaway: before you type your next Copilot prompt, ask one question — do I need an answer, or do I need a change? If it's an answer, stay in Ask mode and keep it fast. If it's a change, decide how far it reaches: one selection means Edit, the whole solution means Agent. Pick the mode from the task, not from muscle memory, and Copilot stops fighting you.
Sources: Ask Mode vs Agent Mode (Microsoft .NET Blog), Copilot ask, edit, and agent modes: what they do and when to use them (The GitHub Blog)