How to Use GitHub Copilot in VS Code Like a Pro

Learn how to use GitHub Copilot in Visual Studio Code with this beginner-friendly step-by-step guide. Discover how to install GitHub Copilot, generate code, write comments to create functions, use AI chat, understand shortcuts, and improve productivity with practical tips and examples.

What Is GitHub Copilot?

GitHub Copilot is an AI-powered code completion tool developed by GitHub in collaboration with OpenAI. It works directly inside Visual Studio Code (and other editors) as an extension, analyzing your code context and suggesting completions — from single lines to entire functions — as you type.

Think of it as autocomplete taken to a whole new level. Instead of just completing a method name, GitHub Copilot in VS Code can read a comment like // fetch user data from API and return JSON and generate the entire implementation for you.

How GitHub Copilot Works

GitHub Copilot is powered by large language models (LLMs) trained on billions of lines of public code. When you write code or a comment in VS Code, the GitHub Copilot extension sends context from your current file to these models and returns AI-generated suggestions inline.

It considers your open files, the surrounding code, comments, function names, and even imported libraries to make its suggestions contextually relevant — not just generic boilerplate.

Benefits of Using GitHub Copilot in VS Code

The case for using GitHub Copilot Visual Studio Code integration is strong across the board:

Supported Programming Languages

GitHub Copilot works with virtually any programming language — but it performs best on languages with a large amount of public training data. Top performers include:

JavaScript / TypeScript, Python, Java, C# / C++, Go, Ruby, Rust, PHP, Swift, Kotlin, and standard web formats like HTML, CSS, and SQL. It also handles shell scripts, YAML, JSON, Markdown, and many more.

Requirements Before Using GitHub Copilot

Before you can start using this AI coding assistant for VS Code, you need three things in place. Let’s walk through each one.

Create a GitHub Account

GitHub Copilot is a GitHub product, so a GitHub account is mandatory. If you don’t have one, go to github.com and sign up — it’s free. Use the same account to subscribe to Copilot and to authenticate the VS Code extension later.

Install Visual Studio Code

Download and install VS Code from code.visualstudio.com if you haven’t already. Any recent version works. GitHub Copilot is officially supported on VS Code 1.75 and above — check Help > About in VS Code to see your version.

Get Access to GitHub Copilot

You’ll need an active GitHub Copilot plan. As of 2025, there’s a free tier with limited completions and a paid Individual plan at around $10/month. Students and verified open-source maintainers can get free access through GitHub Education. See the Pricing section below for a full breakdown. Check out our dedicated post on how to install GitHub Copilot step-by-step for an in-depth walkthrough of the subscription process.

How to Install GitHub Copilot in VS Code

Getting the GitHub Copilot extension running in VS Code takes about two minutes. Here’s the exact process.

Open the Extensions Marketplace

In VS Code, open the Extensions panel using the keyboard shortcut Ctrl+Shift+X (Windows/Linux) or ⌘+Shift+X (Mac). You can also click the puzzle-piece icon in the left Activity Bar.

Install the GitHub Copilot Extension

1. In the search bar at the top of the Extensions panel, type GitHub Copilot.
2. Find the official extension published by GitHub — it should be the top result with millions of installs.
3. Click the blue Install button. This also installs GitHub Copilot Chat as a companion extension automatically.

Sign In to Your GitHub Account

After installation, VS Code will prompt you to sign in. Click Sign in to GitHub in the notification that appears at the bottom right. Your browser opens and guides you through a standard GitHub OAuth flow. Once authorized, VS Code confirms the connection.

Verify That GitHub Copilot Is Working

Open any code file — for example, create test.js. Start typing a comment or function name. If Copilot is active, a gray ghost suggestion appears inline within a second or two. If you see the Copilot icon in the VS Code status bar (bottom right) without a warning badge, you’re all set.

How to Use GitHub Copilot in VS Code

Now for the real meat. Here’s how to actually use GitHub Copilot in VS Code day-to-day — from basic completions to the powerful chat interface.

Generate Code with Comments

The most natural way to drive GitHub Copilot is with plain-English comments. Write a comment that describes what you want, press Enter, and watch the suggestion appear. The more specific your comment, the better the output.

// Function that takes an array of numbers and returns
// the top N highest values, sorted descending
function getTopN(arr, n) {
  return [...arr].sort((a, b) => b - a).slice(0, n);
}

// Function that takes an array of numbers and returns
// the top N highest values, sorted descending
function getTopN(arr, n) {
  return [...arr].sort((a, b) => b - a).slice(0, n);
}

Accept, Reject, or Cycle Through Suggestions

When a ghost-text suggestion appears in VS Code, you have full control:

• Accept — Press Tab to accept the entire suggestion.
• Accept word-by-word — Press Ctrl+→ (Windows) or ⌘+→ (Mac) to accept one word at a time.
• Reject — Press Esc to dismiss and keep typing.
• Cycle through — Press Alt+] or Alt+[ to see the next or previous alternative suggestion.

Use Inline Suggestions While Typing

You don’t need to write a comment first. GitHub Copilot watches your keystrokes and offers completions as you type normally. Begin a function signature, and it may fill in the entire body. Start typing a condition, and it might complete the logic. These inline suggestions are the moment-to-moment experience of using github copilot vscode.

Generate Entire Functions and Classes

For larger blocks — whole classes, complex functions, or multi-method structures — write a doc comment or JSDoc/docstring above the function signature. Copilot reads the type signatures and documentation and generates implementations that align with your intent.

"""
Parses a CSV file at the given path and returns a list of
dictionaries, where each dict represents one row. Skips
empty lines and strips whitespace from all values.
"""
def parse_csv(filepath: str) -> list[dict]:
    import csv
    results = []
    with open(filepath, newline='') as f:
        reader = csv.DictReader(f)
        for row in reader:
            stripped = {k: v.strip() for k, v in row.items() if v.strip()}
            if stripped:
                results.append(stripped)
    return results

"""
Parses a CSV file at the given path and returns a list of
dictionaries, where each dict represents one row. Skips
empty lines and strips whitespace from all values.
"""
def parse_csv(filepath: str) -> list[dict]:
    import csv
    results = []
    with open(filepath, newline='') as f:
        reader = csv.DictReader(f)
        for row in reader:
            stripped = {k: v.strip() for k, v in row.items() if v.strip()}
            if stripped:
                results.append(stripped)
    return results

Ask Questions Using GitHub Copilot Chat

GitHub Copilot Chat is a conversational interface built directly into VS Code. It’s not just a chatbot — it has full access to your workspace, the file you’re editing, selected code blocks, terminal output, and error messages.

Open it with Ctrl+Alt+I or by clicking the Copilot Chat icon in the Activity Bar. You can ask things like:

For deeper guidance on crafting effective prompts, check out our upcoming post on best GitHub Copilot prompts for VS Code.

Best GitHub Copilot Shortcuts in VS Code

Mastering GitHub Copilot shortcuts is what separates casual users from power users. These keyboard shortcuts keep you in flow — no mouse, no menus.

Accept Suggestions

Open Multiple Suggestions

Trigger Suggestions Manually

Open Copilot Chat Quickly

Real Examples of GitHub Copilot in Action

Let’s look at concrete GitHub Copilot examples across different languages and use cases. These showcase what you can realistically expect from the tool day-to-day.

Generate a JavaScript Function

// Debounce: delays function execution until after wait ms
// have passed since the last time it was invoked.
// Supports an optional `immediate` flag to trigger on leading edge.
function debounce(func, wait, immediate = false) {
  let timeout;
  return function(...args) {
    const callNow = immediate && !timeout;
    clearTimeout(timeout);
    timeout = setTimeout(() => {
      timeout = null;
      if (!immediate) func.apply(this, args);
    }, wait);
    if (callNow) func.apply(this, args);
  };
}

// Debounce: delays function execution until after wait ms
// have passed since the last time it was invoked.
// Supports an optional `immediate` flag to trigger on leading edge.
function debounce(func, wait, immediate = false) {
  let timeout;
  return function(...args) {
    const callNow = immediate && !timeout;
    clearTimeout(timeout);
    timeout = setTimeout(() => {
      timeout = null;
      if (!immediate) func.apply(this, args);
    }, wait);
    if (callNow) func.apply(this, args);
  };
}

Create a C# API Endpoint

// GET /api/products/{id} - Returns a single product or 404
[HttpGet("{id:int}")]
public async Task<IActionResult> GetProductById(int id)
{
    var product = await _repository.GetByIdAsync(id);
    if (product == null)
        return NotFound(new { message = $"Product {id} not found" });
    return Ok(product);
}

// GET /api/products/{id} - Returns a single product or 404
[HttpGet("{id:int}")]
public async Task<IActionResult> GetProductById(int id)
{
    var product = await _repository.GetByIdAsync(id);
    if (product == null)
        return NotFound(new { message = $"Product {id} not found" });
    return Ok(product);
}

Write HTML and CSS Faster

GitHub Copilot shines for front-end work too. Writing a CSS card component? Copilot suggests the entire ruleset with hover states, responsive breakpoints, and CSS custom properties — often before you’ve finished the first selector.

/* Responsive product card with image, title, price, and CTA */
.product-card {
  display: flex;
  flex-direction: column;
  background: var(--surface);
  border: 1px solid var(--border);
  border-radius: 12px;
  overflow: hidden;
  transition: box-shadow 0.2s ease, transform 0.2s ease;
}
.product-card:hover {
  box-shadow: 0 8px 32px rgba(0, 0, 0, 0.12);
  transform: translateY(-4px);
}
.product-card__image { width: 100%; aspect-ratio: 4 / 3; object-fit: cover; }
.product-card__body  { padding: 16px; flex: 1; display: flex; flex-direction: column; gap: 8px; }
.product-card__price { font-weight: 700; font-size: 1.1rem; color: var(--accent); margin-top: auto; }

/* Responsive product card with image, title, price, and CTA */
.product-card {
  display: flex;
  flex-direction: column;
  background: var(--surface);
  border: 1px solid var(--border);
  border-radius: 12px;
  overflow: hidden;
  transition: box-shadow 0.2s ease, transform 0.2s ease;
}
.product-card:hover {
  box-shadow: 0 8px 32px rgba(0, 0, 0, 0.12);
  transform: translateY(-4px);
}
.product-card__image { width: 100%; aspect-ratio: 4 / 3; object-fit: cover; }
.product-card__body  { padding: 16px; flex: 1; display: flex; flex-direction: column; gap: 8px; }
.product-card__price { font-weight: 700; font-size: 1.1rem; color: var(--accent); margin-top: auto; }

Generate Unit Tests Automatically

Highlight a function in VS Code, open Copilot Chat, and type “Write unit tests for this function using Jest”. Copilot generates a full test file covering happy paths, edge cases, and error conditions.

// Jest tests for getTopN() utility
describe('getTopN', () => {
  it('returns the top N values sorted descending', () => {
    expect(getTopN([3, 1, 4, 1, 5, 9, 2, 6], 3)).toEqual([9, 6, 5]);
  });
  it('returns all elements when N exceeds array length', () => {
    expect(getTopN([2, 1], 10)).toEqual([2, 1]);
  });
  it('returns empty array for empty input', () => {
    expect(getTopN([], 3)).toEqual([]);
  });
  it('handles negative numbers correctly', () => {
    expect(getTopN([-1, -5, -3], 2)).toEqual([-1, -3]);
  });
});

// Jest tests for getTopN() utility
describe('getTopN', () => {
  it('returns the top N values sorted descending', () => {
    expect(getTopN([3, 1, 4, 1, 5, 9, 2, 6], 3)).toEqual([9, 6, 5]);
  });
  it('returns all elements when N exceeds array length', () => {
    expect(getTopN([2, 1], 10)).toEqual([2, 1]);
  });
  it('returns empty array for empty input', () => {
    expect(getTopN([], 3)).toEqual([]);
  });
  it('handles negative numbers correctly', () => {
    expect(getTopN([-1, -5, -3], 2)).toEqual([-1, -3]);
  });
});

Tips to Get Better GitHub Copilot Suggestions

Copilot is only as good as the context you give it. These habits will dramatically improve the quality of suggestions you get from this AI coding assistant for VS Code.

Write Clear Comments

The single biggest driver of suggestion quality is comment clarity. Vague comments produce vague code. Be explicit about inputs, outputs, edge cases, and constraints. Instead of // get user, write // fetch user from DB by email, return null if not found. The difference in output quality is night and day.

Use Meaningful Function Names

Copilot heavily weighs the name of your function when generating its body. A function named processData() gives Copilot almost no signal. A function named normalizePhoneNumberToE164Format() gives it enormous signal. Invest in descriptive naming — it pays dividends in suggestion quality.

Break Large Tasks into Smaller Steps

Don’t try to generate a 200-line class from a single comment. Break large features into discrete, well-named functions. Generate each piece separately, refine it, then build the next one. Copilot performs best on focused, bounded problems with clear inputs and outputs.

Review AI-Generated Code Carefully

Copilot is impressively capable, but it makes mistakes — sometimes subtle ones. Always review generated code for logic errors, security issues (especially in authentication or SQL), outdated API usage, or missing error handling. Use it as a powerful first draft, not as a final implementation.

Common GitHub Copilot Problems and Fixes

Running into issues? Here are the most common problems people encounter with github copilot vscode and how to fix them fast.

GitHub Copilot Not Showing Suggestions

Authentication or Sign-In Issues

If VS Code shows a sign-in prompt repeatedly, open the Command Palette (Ctrl+Shift+P) and run “GitHub Copilot: Sign Out”, then “GitHub Copilot: Sign In” again. If the browser OAuth flow fails, try opening an incognito/private browser window. Make sure your GitHub account has an active Copilot subscription at github.com/settings/copilot.

GitHub Copilot Extension Not Working

First, check that both extensions are installed and enabled: GitHub Copilot and GitHub Copilot Chat. Go to the Extensions panel and confirm neither is disabled. If they appear enabled but still misbehave, try uninstalling both, restarting VS Code, and reinstalling them fresh from the marketplace.

Slow or Incorrect Suggestions

Slow suggestions usually indicate a network issue — Copilot requires a stable internet connection. Incorrect suggestions are often a context problem: Copilot may be reading an unrelated open file. Close unused editor tabs and ensure the relevant files for your current task are open. Rewriting your comments to be more specific almost always improves accuracy.

GitHub Copilot Pricing and Plans

Free vs Paid Plans

Is GitHub Copilot Worth It?

For most professional developers: yes. The productivity gains on repetitive work, test writing, and boilerplate generation typically far outweigh the monthly cost. For students and hobbyists, the free tier is a great place to start and evaluate whether the paid tier makes sense for your workflow.

The key is understanding it as a tool that augments your skills, not a replacement for understanding your code. Developers who understand what Copilot generates get dramatically more value from it than those who paste suggestions blindly.

GitHub Copilot Alternatives

GitHub Copilot leads the market, but it’s not the only AI coding assistant for VS Code worth considering. Here are the main alternatives as of 2025:

Final Thoughts on Using GitHub Copilot in VS Code

When GitHub Copilot Helps the Most

GitHub Copilot delivers the biggest wins in predictable, pattern-heavy scenarios: writing CRUD operations, generating test suites, scaffolding boilerplate, working with APIs you don’t know well, or grinding through repetitive data transformations. The more context you provide and the more structured your task, the better it performs.

It’s less effective — and requires more review — on novel algorithms, complex business logic, security-sensitive code, or highly domain-specific problems with little public training data analogous to your domain.

Should Beginners Use GitHub Copilot?

This is genuinely nuanced. GitHub Copilot can accelerate learning — watching it generate idiomatic Python or correct TypeScript teaches you patterns faster than reading documentation alone. But there’s a real risk of accepting suggestions without understanding them, which leads to code you can’t debug or maintain.

Whether you’re a seasoned engineer optimizing velocity or a newcomer exploring a new framework, GitHub Copilot in VS Code is one of the most impactful tools you can add to your workflow in 2025. Start with the free tier, invest time in learning how to prompt it well, and treat every suggestion as a starting point — not an endpoint.