Setting Up GitHub Copilot: Agent Mode, MCP and Instructions

Setting Up GitHub Copilot: Agent Mode, MCP and Instructions

Most developers already have GitHub Copilot turned on somewhere — inline completions in VS Code, maybe a chat panel they poke at occasionally. Far fewer have it configured as an actual coding agent: one that reads your repo's conventions, runs your test suite, connects to the tools your team already uses, and opens a pull request you can review instead of a suggestion you have to retype. That gap is mostly a config gap, not a capability gap. This is a walkthrough of the three pieces that close it: repository instructions, agent mode, and MCP servers, plus where Copilot's own coding agent fits in if you want it working on issues while you're not at the keyboard.

Start with repository instructions

Copilot reads two kinds of instruction files before it acts, and both live under .github/ in your repo so the whole team shares them through version control rather than personal settings.

/.github/copilot-instructions.md is the repo-wide file: project structure, build and test commands, coding conventions, anything you'd tell a new hire on day one. /.github/instructions/ lets you scope guidance to specific paths or file types with individual *.instructions.md files — different rules for the API routes than for the UI components, for example. If you're setting up a monorepo, the path-specific files matter more than the top-level one; a single instructions file that tries to cover a Rails API and a React frontend tends to produce generic advice that fits neither well.

A minimal starting file:

# .github/copilot-instructions.md

## Build & test
- Install: `npm install`
- Run tests: `npm test`
- Lint: `npm run lint`

## Conventions
- TypeScript strict mode; no `any` without a comment explaining why
- Components live in `src/components/<name>/<name>.tsx` with a co-located test file
- Prefer editing existing files over creating new abstractions

If you're deploying Copilot's cloud coding agent (the version that works issues autonomously rather than pairing with you live), there's a third file worth adding: copilot-setup-steps.yml, which pre-installs dependencies so the agent's sandbox is ready to run tests immediately instead of spending its first few minutes on npm install.

Turn on agent mode in the editor

The chat panel in VS Code and JetBrains has more than one mode, and which one you're in changes what Copilot is allowed to do. Agent mode is the one that matters for actual development work: it can run terminal commands, edit multiple files across a change, and decide on its own what additional context it needs beyond whatever you've got open or selected.

A few things worth knowing before you rely on it:

• Starting a chat message with ! runs a terminal command immediately, without a separate approval step — useful for quick checks, but worth being deliberate about in a repo with real infrastructure access.
• You can steer or stop a running request mid-task from the same dropdown that lets you queue up the next message, rather than waiting for it to finish and then correcting course.
• Each chat session can be configured with its own agent harness, role and permission level, so a session scoped to "explore and report" doesn't carry the same write access as one scoped to "implement this ticket."

None of this replaces reviewing the diff. Agent mode changes how much Copilot can attempt in one pass, not how much you should trust the result unread.

GitHub Copilot Freemium

AI pair programmer and coding agent across VS Code, JetBrains, the CLI and GitHub

Free plan, paid from $10/mo

🔥 Free Copilot for verified students

8.7 Visit ↗

Connect MCP servers for real context

Agent mode is only as useful as what it can see and touch. By default that's your open files and whatever it can infer from the repo — it doesn't know your issue tracker, your design files, or how your staging environment is actually behaving. MCP servers close that gap by giving Copilot tools it can call directly, the same standard covered in more depth on /glossary.

Copilot in VS Code reads MCP configuration from one of three places:

Commit the workspace version to source control if the whole team should get the same servers automatically. A local stdio server and a remote http server look like this side by side:

{
  "servers": {
    "playwright": {
      "command": "npx",
      "args": ["-y", "@microsoft/mcp-server-playwright"]
    },
    "github": {
      "type": "http",
      "url": "https://api.githubcopilot.com/mcp"
    }
  }
}

For anything that needs a secret — an API token, a database URL — the docs are explicit about not hardcoding it into the JSON. Use an input variable (${input:variableName}) or an environment file instead, so the config file itself stays safe to commit. Once a server is added, enable it either from the Extensions view (right-click → Enable) or by running the "MCP: List Servers" command; VS Code discovers the server's tools automatically the first time you confirm you trust it.

Two servers worth starting with if you're not sure where to begin:

GitHub MCP Server 🔌 MCP serverFree

GitHub's official MCP server: issues, pull requests, code, Actions and security alerts

★ 33k · +132 this week

9.0 GitHub ↗

Playwright MCP 🔌 MCP serverFree

Microsoft's MCP server for browser automation with Playwright

★ 38k · +196 this week

9.1 GitHub ↗

The GitHub server gives Copilot direct access to issues, pull requests, Actions runs and security alerts — the context it would otherwise have to guess at from file contents alone. The Playwright server lets it drive a real browser, which matters the moment "write a test" becomes "write a test and confirm it actually passes against the running app" instead of code that merely compiles. More MCP servers across other categories — databases, cloud infra, web search — are listed on /mcp-servers for Copilot specifically, and the full catalog is on /ecosystem.

Add reusable skills instead of repeating yourself in chat

If you find yourself pasting the same "always write tests first, then implement, then verify the tests actually run" instructions into chat every session, that's a sign to move it into a skill instead of a prompt. Skills are self-contained instruction packs that Copilot (and most other agent-mode tools) can load on demand rather than you retyping process every time.

Superpowers 🧩 SkillFree

A skills library that makes coding agents plan, test-first and debug systematically

★ 294k · +2.7k this week

9.0 GitHub ↗

A pack like this bundles the habits that are easy to state once and easy to forget under deadline pressure — plan before editing, write the failing test before the fix, verify rather than assume. Installing one is a smaller lift than writing your own from scratch, and it's a reasonable first thing to try before building custom instructions for a whole team. VS Code's Agent Customizations editor is where these get toggled on or off per session, the same place agent mode's permission level lives.

Or skip the editor: Copilot CLI

If most of your work already happens in a terminal, the editor extension isn't the only door in. Copilot CLI puts the same chat-and-agent experience directly in your shell, which is convenient if you're already living in tmux or SSH'd into a remote box without a full IDE attached.

Install it with npm, or one of the platform-specific options:

# npm, any platform
npm install -g @github/copilot

# macOS/Linux via Homebrew
brew install --cask copilot-cli

# macOS/Linux install script
curl -fsSL https://gh.io/copilot-install | bash

# Windows via WinGet
winget install GitHub.Copilot

On first launch, if you're not already logged in to GitHub, it prompts you to run the /login slash command. If you'd rather authenticate non-interactively — in CI, for instance — generate a fine-grained personal access token scoped to "Copilot Requests" and export it as COPILOT_GITHUB_TOKEN, GH_TOKEN, or GITHUB_TOKEN. You'll need an active Copilot subscription either way, and on Windows, PowerShell v6 or newer.

The same .github/copilot-instructions.md file and MCP configuration you set up for the editor apply here too — it's the same underlying agent, just without the GUI around it. That consistency is the main reason to bother with both: instructions and MCP servers you write once work whether you or a teammate happens to be in VS Code, JetBrains, or a terminal that day.

Let the cloud agent work issues without you

Everything above assumes you're sitting at the keyboard, driving agent mode turn by turn. Copilot's coding agent can also work independently: assign it a GitHub issue, and it plans, edits, runs your checks, and opens a pull request for review — all in a cloud sandbox, not your local machine.

It performs noticeably better on some kinds of tasks than others. Good candidates: bug fixes with a clear repro, UI updates, test coverage gaps — anything you could describe completely enough that the description alone would work as a prompt. Poor candidates: large refactors, security-sensitive changes, live production incidents, or anything that needs domain judgment the issue text doesn't capture. If the agent's first attempt on a PR isn't quite right, commenting @copilot on the pull request lets you request specific refinements, and batching several review comments through "Start a review" gets you one coherent revision instead of the agent reacting to each comment separately.

A minimal setup, in order

If you're doing this for the first time this week, the order that pays off fastest:

1. Write .github/copilot-instructions.md — even a short one beats none
2. Turn on agent mode in VS Code or JetBrains and try it on one real, small task
3. Add one MCP server that removes a context gap you hit constantly (GitHub issues, your database, your design tool)
4. Only then reach for the cloud coding agent, on a task narrow enough to describe completely in the issue

Skipping straight to step 4 without the instructions file in place is the most common reason a first attempt at Copilot's coding agent disappoints — it's not under-capable, it's under-briefed. Check /deals if you're deciding between Copilot's individual and business tiers; verified students get free access, and that's usually the fastest way to try agent mode before committing a team to it.