I spent the first two years of Copilot's existence using it as a very fast autocomplete. It would finish my function names, suggest a whole function body I'd tweak, and let me ask questions in the chat panel when I was stuck. Useful. Incrementally better than before. Not a step-change. Not yet.
Then I actually read the documentation and learned what agent mode and Copilot CLI were designed for. And I want to save you two years of underusing a tool you're probably already paying for.
What chat mode is — and why it's Copilot's least powerful feature
The chat pane in VS Code is conversational. You ask a question, it answers. You ask it to write a function, it writes the function. You copy it into your file. It's a faster version of what you were already doing with Stack Overflow and your own knowledge — you're still the one making every decision, writing every edit, and running every command.
This is fine. It's faster than not having it. But it's not a qualitative change in how you work. You're still doing the same job. Copilot is giving you better suggestions.
Agent mode is different in kind, not just degree.
What Copilot agent mode actually does
Agent mode is a task executor. You describe what you want done — at a high level, in plain English — and Copilot reads your codebase, makes a plan, edits multiple files, runs commands, reads the output, notices errors, fixes them, and keeps going until the task is complete or it needs your input.
Here's a concrete example. I was building a client project — a Node.js backend with a set of API routes that needed rate limiting added across all of them. In chat mode, I would: ask how to implement rate limiting with express-rate-limit, copy the code, figure out which files need updating, make the changes across 8 route files, install the package, test it. Probably 45 minutes of careful, boring work.
In agent mode: "Add rate limiting to all API routes in this project. Use express-rate-limit. Limit to 100 requests per 15 minutes per IP. The auth routes (/api/auth/login and /api/auth/register) should be stricter — 10 requests per 15 minutes. Apply this globally but allow the rate limits to be configured via environment variables."
It read the project structure. Found every route file. Identified the server setup file. Installed express-rate-limit. Wrote the rate limiter configuration with the different limits I specified. Applied it to the correct middleware position in the Express setup. Created the environment variable references. Ran the tests. One test failed because of the tighter auth route limit — it fixed the test config. Done. About 8 minutes, most of which was me watching.
That's not "autocomplete." That's a developer-level task being executed autonomously.
GitHub Copilot CLI — the terminal power most people completely miss
Separate from the editor: Copilot CLI runs in your terminal. Two commands:
gh copilot suggest — describe what you want to do in plain English, get the shell command. "Find all files modified in the last 24 hours that are larger than 1MB." "Kill all processes running on port 3000." "Show me which Docker containers are using the most memory." "Recursively rename all .jpeg files to .jpg in this directory." It gives you the command, explains it, and asks if you want to run it, copy it, or revise the prompt.
gh copilot explain — paste any command you don't understand, get a plain-English breakdown. Useful when you find a script someone wrote 3 years ago and it's doing something arcane with awk and sed and you need to know if it's safe to modify.
This sounds modest. It isn't. I spend a non-trivial amount of time in a terminal — deploying to VPS servers, writing automation scripts, managing git, configuring nginx. The commands I reach for every day are the ones I know by heart. The ones I reach for occasionally — specific find commands, complex git history operations, server diagnostics — I used to look up. Now I describe what I need and get the command right the first time.
For Indian developers working with remote Linux servers (which is most of us managing our own VPS for client projects) — this is hours per month returned. Especially for server commands where a wrong flag can do real damage. Getting the exact command verified, with an explanation of what each flag does, is fast and safe.
The Copilot multi-agent setup for serious task automation
For complex projects — not just single tasks — you can use Copilot agent mode with multiple sub-agents. Define your project structure, give Copilot workspace context through the VS Code workspace settings, and use agent-to-agent coordination for tasks that span areas (one agent for the backend API changes, one for the tests, one reviewing the documentation). This is still evolving as of April 2026, but the trajectory is clear: the editor is becoming an orchestration environment, not just a writing environment.
The developers who will be most productive over the next 3–5 years are the ones who understand how to structure tasks for agent execution — how to break work into clear, verifiable pieces, how to write prompts that give the agent enough context to act independently, and how to review agent-produced code critically rather than blindly accepting it.
Specific workflows I've built with Copilot agent mode
To make this concrete rather than theoretical, here are the actual recurring workflows I've set up for client projects using agent mode:
Database migration preparation: "Analyse the current schema in /src/db/schema.ts. I need to add a organisations table with multi-tenancy support — each User should belong to an Organisation, and every resource should be scoped to an Organisation. Generate the migration file, update the schema types, update the User type to include organisationId, and identify the 5 API routes that will need updating to enforce organisation-level access. Don't make those API route changes yet — just list them." This is a scoping and analysis task. Agent mode reads the codebase, understands the dependencies, and produces a change plan I can review before implementation starts.
Test suite generation: "Generate Jest tests for every function in /src/utils/formatters.ts. For each function, write at minimum: one test for the happy path with typical input, one test with empty/null/undefined input, and one test with edge case input. Follow the test patterns already established in /tests/unit/paymentUtils.test.ts." Agent mode reads both files, understands the existing test style, and produces a test file that I review and approve. This task takes 25+ minutes to do manually and 4 minutes with agent mode.
Code review assistance: "Review the changes in the current git diff. Identify: any functions with side effects that aren't obvious from their names, any places where error handling is missing, any potential null reference errors, and any places where the code doesn't match the established patterns in the rest of the file." This is a true code review pass — the agent reads the diff, understands the codebase context, and produces specific observations. It doesn't replace human code review, but it catches the mechanical issues that reviewers sometimes miss when they're reading quickly.
Also see: Why GitHub Copilot beats Claude Code for most developers and Backend developers: your future is building AI agents.