ع
💻 Coding

How to Use GitHub Copilot in the Editor You Already Have

A practical guide to running Copilot smartly after the June 2026 credit-system change, and knowing when to trust its output versus review it line by line.

Beginner7 min read

What you'll be able to do by the end

  • Understand that it's an extension living inside your current editor (VS Code, JetBrains, Visual Studio, Neovim, Xcode) — you don't need to change tools to try it
  • Know the June 2026 change: chat, agent mode, code review, and the CLI are now billed from a usage-based credit budget, while inline completions themselves remain unmetered on paid plans
  • Budget the free plan realistically: 2,000 completions per month covers a hobby project, but daily professional coding burns through it in a week — and students get full free access
  • Write a clear comment above the code and keep related files open as context — these are the two strongest levers on suggestion quality
  • Never trust output without review — it writes confident code even when calling functions that don't exist

Before you start

  • An editor already installed (VS Code, JetBrains, Visual Studio, Neovim, or Xcode) and a GitHub account
  • The ability to read and review code yourself — reviewing is part of correct usage, not an optional extra step

GitHub Copilot lives inside the editor you already use — VS Code, JetBrains, Visual Studio, Neovim, Xcode — without making you build a new environment from scratch. It was the first tool of its kind at this scale, and it remains the lowest-friction way to add AI to an existing development setup: suggestions appear as gray ghost text at your cursor, you press Tab to accept and keep moving.

One important thing changed as of June 2026, and you need it before setting expectations: chat, agent mode, automatic code review, and the CLI now bill against a credit budget based on actual token consumption across all plans. Prices didn’t change, but heavy chat users started hitting limits that didn’t exist before. The good news: plain inline completions — the part most people use most — stayed unmetered on paid plans.

This guide covers practical use from installation through agent mode, focusing on the two habits that genuinely change output quality — commenting above the code and keeping files open as context — plus the explicit warning that it writes confident code that isn’t always correct.

The steps

The steps below run from installation and plan selection to the daily habits that determine whether the tool actually helps you or collides with you constantly.

Steps

  1. Step 1: Install the extension, sign in with GitHub, and pick a plan for your real usage

    Install the Copilot extension in your editor and sign in with your GitHub account. Then choose a plan based on actual usage, not enthusiasm: Free gives 2,000 completions per month with limited chat — enough for a hobby project or occasional scripts, not daily professional coding. Pro at $10/month gives unlimited completions plus a monthly credit allowance for chat and agent mode. Pro+ at $39 gives a much larger credit budget and access to advanced models. If you're a verified student or maintain a well-known open-source project, it's entirely free through the GitHub Student Developer Pack or the open-source program.

    Note: If you're a student, activate the Student Developer Pack first before paying for anything — the difference is significant.

  2. Step 2: Write a comment above the code and keep related files open as context

    The strongest way to steer suggestions is a clear comment above an empty function describing exactly what you want it to do — before writing any code line. Copilot reads your repository itself as context, so suggestions follow your project's conventions rather than generic textbook patterns. The suggested text appears as gray ghost text at your cursor: press Tab to accept, Esc to dismiss, Alt+] to cycle alternatives. Keep related files open in tabs too — Copilot reads open tabs as additional context, so simply opening your model file or definitions file changes the quality of what it proposes.

    Note: If a suggestion isn't right first time, try Alt+] before editing manually — sometimes the second or third alternative is more accurate.

  3. Step 3: Use chat for real questions, agent mode for tasks spanning multiple files

    Open Copilot Chat when you need to understand an unfamiliar file or ask about existing code — not for every routine question, because after June 2026 chat draws down from a limited credit balance, so save it for questions that genuinely deserve it. Agent mode takes a written task, edits multiple files, and opens a pull request for you to review — use it for work spanning many files, not a trivial one-function edit you'd finish faster yourself. There's also automatic code review that comments on pull requests before any human sees them — a useful first gate, but no substitute for your own review.

    Note: Always prefer plain inline completions for routine typing — they stay unmetered on paid plans, so preserve your credit balance for chat and agent mode.

  4. Step 4: Document your project conventions once via copilot-instructions.md

    Instead of re-explaining the same rules every session — naming style, tooling choices, error handling approach — add a `.github/copilot-instructions.md` file documenting your project conventions once. Copilot reads it as standing context, so you save time and get suggestions closer to your style from the start instead of correcting them every time.

    Note: If your team uses Copilot, this file keeps everyone's suggestions consistent with each other — not just yours.

  5. Step 5: Always review output, and check the training setting if you work on private code

    Trust no suggestion blindly. Copilot writes plausible code with total confidence even when it calls functions or properties that don't exist in your project — review isn't an extra step, it's part of how the tool works. Its strength also varies by language: Python, JavaScript, TypeScript, Java, Go, and C# are strongest because training data there is deepest; it handles rarer languages but suggestion quality drops noticeably and you'll correct more than you accept. On individual plans, whether your code trains models is a setting you must verify yourself in Copilot settings — on Business and Enterprise it's off by default, but on personal accounts check it yourself before using the tool on private code or sensitive IP.

    Note: If you work in a rarer language and keep correcting more than accepting, that's normal — suggestion quality genuinely is weaker there, not misconfigured on your end.

Common mistakes — and how to avoid them

MistakeSubscribing to Pro+ believing chat and agent mode became unlimited like before June 2026, without checking the credit balance.

Do this insteadKnow that chat, agent mode, code review, and the CLI are all billed from a usage-based credit budget on every plan — inline completions are what remain unmetered on paid plans, so save chat for real questions.

MistakeStaying on the free plan for daily professional coding, assuming 2,000 monthly completions will last the month.

Do this insteadBe honest about your volume: 2,000 covers a hobby project or occasional scripts, but daily professional coding consumes it within the first week — move to Pro, or check Student Developer Pack eligibility if you're a student.

MistakeAccepting every gray suggestion with Tab without reading it, trusting it because it looks like sound code.

Do this insteadReview every suggestion before accepting — Copilot writes confident code even when calling functions that don't exist; treat each output as a draft needing verification, never a final result.

MistakeHanding agent mode a huge restructuring task spanning the whole project architecture, expecting tools built natively for that purpose.

Do this insteadUse agent mode for clearly-briefed multi-file tasks, not massive architectural rewrites — tools like Cursor and Windsurf are built for that scale of change; Copilot's real strength is staying out of your way while you type.

❓ Frequently asked questions

Is GitHub Copilot free?

There's a genuine free plan: 2,000 inline completions per month with limited chat — enough for a hobby project or occasional scripts, not daily professional work. It's also completely free for verified students via the GitHub Student Developer Pack and for maintainers of well-known open-source projects.

What exactly changed in June 2026?

Prices stayed the same, but billing changed: every plan now meters chat, agent mode, automatic code review, and the CLI against a token-consumption credit budget. Plain inline completions — the thing most people use most — remain unmetered on paid plans.

Copilot or Cursor?

It depends how willing you are to switch editors. Happy with your current editor and just want AI added on top? Copilot is the lowest-friction option. Willing to move editors for deeper integration? Cursor is stronger on multi-file edits and large refactors. Many developers run Copilot for daily suggestions and a second tool for big tasks.

Is my code used for training?

On Business and Enterprise plans, no — it's off by default. On individual accounts it's a setting you must check yourself in Copilot settings — worth verifying before using the tool on private code or sensitive intellectual property.