Updated for 2026. This guide replaces our earlier “Copilot X” tutorial — GitHub retired that branding, and the product has changed dramatically since then. Everything below reflects GitHub Copilot as it works today.
Remember “GitHub Copilot X”? That was the umbrella name GitHub used back in 2023–2024 for a set of experimental features: chat in your editor, a CLI assistant, pull request summaries. The “X” is gone now — not because the features died, but because they all shipped. What used to be a waitlist of promises is now simply GitHub Copilot: an AI pair programmer that autocompletes your code, answers questions in chat, reviews your pull requests, runs in your terminal, and — the biggest shift of all — works as an autonomous agent that can take a GitHub issue and open a pull request on its own.
This guide walks you from zero to advanced usage, with real C# examples along the way (we are a .NET-leaning blog, after all). No fluff — just what you need to actually be productive with it.
What GitHub Copilot Is in 2026 (and What Changed)
Today’s Copilot is really five tools sharing one subscription:
- Inline suggestions — the classic autocomplete-on-steroids as you type, plus next edit suggestions that predict your following change across the file (available in VS Code, Xcode and Eclipse).
- Copilot Chat — a chat panel in your IDE, on github.com, in GitHub Mobile and even Windows Terminal. Ask questions about your code, generate tests, explain unfamiliar files.
- Agent mode — you give Copilot a task inside your editor, and it edits multiple files, runs commands, fixes its own compile errors, and iterates until done. Generally available in VS Code and JetBrains IDEs since early 2026.
- The cloud coding agent — assign a GitHub issue to Copilot and it works in the cloud: researches your repo, plans, writes code, and opens a pull request for your review.
- Supporting cast — Copilot CLI for your terminal, AI code review on pull requests, Copilot Spaces for sharing context, and MCP (Model Context Protocol) support to connect external tools.
The other big 2026 change is how you pay. Code completions are unlimited on every paid plan, but chat, agent mode, code review and the CLI now draw from a monthly allowance of AI credits. More on that (and how not to burn through them) below.
Plans and Pricing: What You Actually Need
Here’s the current lineup:
- Free — $0. Up to 2,000 code completions/month plus a limited allowance of chat and agent usage. Genuinely usable for evaluation, not for daily work.
- Student — $0 for verified students, with unlimited completions.
- Pro — $10/month. Unlimited completions, access to the cloud coding agent, and 1,500 monthly AI credits.
- Pro+ — $39/month. Everything in Pro with 7,000 credits and premium model access.
- Max — $100/month. 20,000 credits and priority access to new models. For heavy agent-mode users.
- Business / Enterprise — $19 and $39 per seat/month, adding centralized policy management, IP indemnity and organization-wide controls.
Our honest take: start Free to evaluate, then move to Pro. The $10 Pro plan is the sweet spot for individual developers — unlimited completions cover 80% of the daily value, and 1,500 credits are plenty if you use chat deliberately rather than compulsively. Only consider Pro+ or Max once you catch yourself running agent-mode sessions daily, because agentic tasks are token-hungry and consume credits far faster than simple chat questions.
Getting Started: Setup in VS Code (5 Minutes)
- Sign in to your GitHub account and enable Copilot at github.com/features/copilot (the Free plan needs no card).
- In VS Code, install the GitHub Copilot extension — it now bundles chat, agent mode and edit suggestions in one package.
- Sign in when prompted, and check the Copilot icon in the status bar shows it’s active.
- Optional but recommended for .NET folks: install the C# Dev Kit extension too. Copilot’s suggestions get noticeably better when the language server gives it rich type information.
JetBrains Rider users: install the “GitHub Copilot” plugin from the marketplace — completions, chat and agent mode all work there now, which wasn’t true in the Copilot X days. Visual Studio 2022+ ships with Copilot integration built in.
Level 1 — Inline Suggestions Done Right
The habit that separates productive Copilot users from frustrated ones: write intent first. Copilot reads your file top to bottom; a comment or a well-named signature is a prompt.
// Parse a Brazilian CPF string, stripping punctuation,
// and validate its two check digits. Return null when invalid.
public static string? NormalizeCpf(string input)
{
// ← this is where YOU stop typing. Pause here, and Copilot
// proposes the entire implementation as a gray "ghost text"
// suggestion — press Tab to accept it.That’s the technique: you write the comment and the method signature, then pause. Copilot produces the full implementation — punctuation stripping, modulo-11 check digits and all. Without the comment, you’d get a generic string sanitizer. The comment is doing the heavy lifting.
Three keyboard essentials: Tab accepts, Esc dismisses, and Alt+] cycles alternative suggestions. Also try accepting suggestions word-by-word (Ctrl+Right Arrow) when the suggestion is 90% right — faster than accepting everything and editing.
Next edit suggestions deserve a special mention: rename a parameter or change a type, and Copilot proposes the matching edits everywhere else in the file. For refactoring-heavy sessions it quietly saves more time than chat does.
Level 2 — Chat, Slash Commands and Context
Open chat with Ctrl+Alt+I (VS Code). The skill here is scoping context. Three prefixes matter:
#file— pin a specific file into the conversation@workspace— let Copilot search your whole project (“@workspace where do we configure JWT validation?”)/tests,/explain,/fix— slash commands for the common asks
A workflow that works well for .NET: select a method, then /tests using xUnit, cover the null and empty-input edge cases. Copilot generates the test class with your project’s existing test conventions if a test project is in context. Review, run, adjust — still faster than writing the scaffolding yourself.
Since 2025, Copilot also has a model picker. You’re no longer locked to one vendor: current options include Anthropic’s Claude 5 family (Sonnet 5, Opus 5), OpenAI’s GPT-5.x line, and Google’s Gemini 3.x, among others. Practical guidance: the default model is fine for completions and quick questions; switch to a top-tier model (Claude Opus 5 or GPT-5.5-class) for architecture discussions and gnarly debugging — those chats consume more credits but produce meaningfully better answers.
Level 3 — Custom Instructions: The Most Underrated Feature
Drop a file at .github/copilot-instructions.md in your repo and every chat and agent session reads it automatically. This is where you encode your team’s conventions once instead of repeating them in every prompt:
# Copilot instructions for this repo
- .NET 10, C# 14, nullable reference types enabled
- Prefer minimal APIs over controllers for new endpoints
- Data access goes through repository interfaces in src/Core — never inject DbContext into endpoints
- Tests: xUnit + FluentAssertions, naming: MethodName_Scenario_ExpectedResult
- Never suggest Newtonsoft.Json; we use System.Text.JsonThe difference is dramatic: suggestions stop fighting your architecture and start following it. If you adopt one thing from this guide, make it this.
Level 4 — Agent Mode: A Real Walkthrough
Agent mode is where Copilot stops being autocomplete and starts being a junior developer you supervise. Switch the chat dropdown from “Ask” to “Agent” and give it a task-sized goal. Let’s walk through a real one on an ASP.NET Core API:
Add rate limiting to all public endpoints using the built-in
.NET rate limiter. Fixed window, 100 requests/minute per client IP,
configurable via appsettings.json. Return 429 with a Retry-After header.
Update the integration tests to cover the limit being hit.Here’s what actually happens, step by step:
- It plans first. Copilot lists the files it intends to touch:
Program.cs,appsettings.json, a newRateLimitingOptions.cs, and the test project. You see the plan before anything changes. - It edits multiple files, showing you a diff view per file as it goes —
AddRateLimiterregistration, the options class bound to configuration, the middleware order fix (rate limiter before authorization, a detail juniors get wrong). - It asks permission to run commands. When it wants to execute
dotnet buildordotnet test, you approve each command explicitly. It never runs anything you didn’t see. - It reads its own failures. First build fails? It reads the compiler error, fixes the missing
using, rebuilds. A test asserts the wrong status code? It updates the assertion and explains why. - You review the final diff like any pull request, then keep or discard each file’s changes.
The supervision cost is real — expect to redirect it once or twice per session (“use the typed options pattern, not raw IConfiguration”). But for well-scoped tasks it reliably turns 45 minutes of plumbing into 10 minutes of review. The keyword is well-scoped: notice how the prompt above specifies the algorithm, the limits, the config location, the error contract and the test expectation. Vague prompts produce vague code and burn credits on retries.
The cloud coding agent extends this to GitHub itself: assign an issue to Copilot like you’d assign a teammate, and it works in a cloud environment, then opens a PR tagged for your review. It shines on well-scoped, boring work: dependency bumps with API migrations, adding test coverage to an untested module, converting controllers to minimal APIs. It struggles when the issue is vague — “make the app faster” will waste credits and your patience.
Two rules for not burning credits:
- Scope tightly. One agent session ≈ hundreds of chat questions in token terms. A vague prompt that needs three retries costs more than doing it yourself.
- Set a spending limit. In your GitHub billing settings you can cap overage spending — do this on day one, especially on a team plan.
Level 5 — Connecting Your World with MCP
Out of the box, agent mode only sees your code. MCP (Model Context Protocol) is how you give it eyes on everything else — your database, your issue tracker, your internal docs. An MCP server is a small adapter that exposes a tool (queries, API calls) in a standard format any AI agent can use.
Concrete example: connect Copilot to your PostgreSQL database so it can inspect the real schema instead of guessing from your EF Core models. In VS Code, create .vscode/mcp.json in your workspace:
{
"servers": {
"postgres": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-postgres",
"postgresql://localhost/appdb"]
}
}
}Now in agent mode, a prompt like “the orders endpoint is slow — check the actual table and indexes, then optimize the LINQ query in OrdersRepository” lets Copilot query the real schema, spot the missing index on orders.customer_id, and propose both the EF migration and the query rewrite. Without MCP it would be guessing; with it, it’s diagnosing.
The same mechanism connects GitHub’s own MCP server (issues, PRs), Playwright for browser testing, or any internal tool your team wraps. In 2026 this is the biggest lever for making Copilot genuinely useful beyond the editor — and it’s where the ecosystem is moving fastest.
Level 6 — Reusable Prompts, CLI and Code Review
Prompt files: for tasks you repeat weekly, stop retyping instructions. Save them as .prompt.md files in .github/prompts/ — for example an api-endpoint.prompt.md that encodes your team’s full checklist for a new endpoint (validation, ProblemDetails errors, OpenAPI annotations, integration test). Then invoke it in chat by name whenever you add an endpoint. Combined with custom instructions, this turns Copilot from a generic assistant into your team’s assistant.
Copilot CLI: after installing (gh extension install github/gh-copilot if you use the GitHub CLI), ask your terminal things like gh copilot suggest "find all csproj files still targeting net6.0" and get the exact command back, explained. Great for the git incantations nobody memorizes.
Copilot code review: enable it on a repository and every pull request gets an AI first-pass review — it flags null-handling gaps, async pitfalls (async void, fire-and-forget tasks), and obvious logic slips before a human ever looks. On a team, set it as a required first reviewer: it doesn’t replace your reviewer, it makes their time count.
Troubleshooting the Classics
- Suggestions stopped appearing — check the status bar icon first; nine times out of ten you’re signed out or the file type is disabled in settings.
- Suggestions are generic or wrong for your stack — you’re missing context. Open the related files (Copilot reads your open tabs), add custom instructions, and name things descriptively.
- Chat says you’re out of credits — completions still work regardless. Check Settings → Billing on GitHub to see usage; consider whether those agent sessions were worth it, or upgrade.
- Agent mode stuck in a fix-fail loop — stop the session, tighten the prompt with the failing detail spelled out, and restart. Three failed iterations means the task needs decomposing, not more retries.
- Corporate proxy blocks it — Copilot needs access to
*.githubcopilot.com; your IT team can allowlist it.
The Bottom Line
The “Copilot X” era was about promise; 2026 Copilot is about routine. The developers getting the most from it aren’t the ones generating the most code — they’re the ones who feed it context deliberately: intent-first comments, custom instructions files, MCP connections, tightly scoped agent tasks. Treat it like a very fast junior developer with encyclopedic knowledge and zero memory of your team’s conventions unless you write them down.
Start free, learn the inline + chat workflow, add custom instructions to your main repo this week — then graduate to agent mode, and only wire up MCP once you have a real use for it. That order will save you money and frustration — and by the time you’re assigning issues to the cloud agent, it’ll feel less like magic and more like delegation.
Related guides on AI Mind Center: Running AI Locally with Ollama in .NET · Setting Up Microsoft.Extensions.AI Step by Step
Questions about using Copilot in your .NET workflow? Reach out via our contact page — reader questions regularly become future guides.
