GitHub Copilot & AI-Assisted Coding — Complete Guide

# Install from Extensions panel:
# Search "GitHub Copilot" → Install

# Or from CLI:
code --install-extension GitHub.copilot
code --install-extension GitHub.copilot-chat

# Sign in:
# Ctrl+Shift+P → "GitHub Copilot: Sign In"
# Follow the browser authentication flow

# File → Settings → Plugins → Marketplace
# Search "GitHub Copilot" → Install

# Or install IdeaVim compatibility:
# Install "IdeaVIM" + "Copilot IdeaVim Extension"

# Sign in:
# Tools → GitHub Copilot → Sign In

-- Using lazy.nvim:
{
  "github/copilot.vim",
  event = "InsertEnter",
  config = function()
    vim.g.copilot_enabled = true
    vim.g.copilot_filetypes = {
      ["*"] = true,
      ["markdown"] = false,
      ["yaml"] = false,
    }
  end,
}

-- Copilot Chat (Neovim):
{
  "CopilotC-Nvim/CopilotChat.nvim",
  dependencies = {
    { "github/copilot.vim" },
    { "nvim-lua/plenary.nvim" },
  },
  opts = {
    model = "claude-sonnet-4-20250514",
    auto_insert_mode = true,
  },
  keys = {
    { "<leader>cc", ":CopilotChat<CR>", desc = "Open Copilot Chat" },
    { "<leader>ce", ":CopilotChatExplain<CR>", desc = "Explain code" },
    { "<leader>ct", ":CopilotChatTests<CR>", desc = "Generate tests" },
  },
}

// Basic completion:
// Type a function name and opening brace:
function validateEmail(email) {
    // Copilot suggests the body. Press Tab to accept.
    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
    return emailRegex.test(email);
}

// Comment-driven completion:
// Write a comment describing what you want:
// Fetch user data from API and cache for 5 minutes
async function fetchUserData(userId) {
    // Copilot generates:
    const cacheKey = `user_${userId}`;
    const cached = await cache.get(cacheKey);
    if (cached) return JSON.parse(cached);

    const response = await fetch(`/api/users/${userId}`);
    const data = await response.json();
    await cache.set(cacheKey, JSON.stringify(data), 300);
    return data;
}

# Tab               → Accept suggestion
# Ctrl+Right        → Accept partial word
# Ctrl+Enter        → Open suggestion in new tab
# Alt+] (or [)      → Show next/previous suggestion
# Escape            → Dismiss suggestion
# Ctrl+Shift+Enter  → Accept suggestion (JetBrains)

# VS Code:
# Ctrl+Shift+I → Open Copilot Chat
# Ctrl+Shift+P → "Copilot Chat: Ask a Question]
# JetBrains:
# Alt+Insert → Copilot Chat
# Or click the Copilot Chat tool window

# Common chat commands:
# /explain     → Explain selected code
# /fix         → Suggest fix for selected code
# /tests       → Generate tests for selected code
# /optimize    → Optimize selected code
# /doc         → Add documentation
# /clear       → Clear chat history

# Select this function and ask /explain:
def calculate_checksum(data: bytes) -> int:
    checksum = 0
    for byte in data:
        checksum = (checksum << 8) ^ byte
        for _ in range(8):
            if checksum & 0x8000:
                checksum = (checksum << 1) ^ 0x1021
            else:
                checksum <<= 1
        checksum &= 0xFFFF
    return checksum

# Copilot Chat response:
# This function calculates a CRC-16 checksum using the polynomial 0x1021.
# It processes each byte by XORing with the current checksum, then
# iterates 8 bits per byte, conditionally applying the polynomial
# based on the most significant bit.

// Select code in your editor and ask:
// /fix "This function doesn't handle empty arrays]
function processItems(items) {
    return items.map(item => item.value)
                .filter(val => val > 0)
                .reduce((sum, val) => sum + val, 0);
}

// Copilot suggestion:
function processItems(items) {
    if (!items || items.length === 0) {
        return 0;  // Early return for empty/null input
    }
    return items
        .map(item => item.value)
        .filter(val => val > 0)
        .reduce((sum, val) => sum + val, 0);
}

# .github/copilot-instructions.md

## Coding Standards
- Use TypeScript strict mode
- Prefer functional components with hooks over class components
- Use `zod` for runtime validation
- Use `neverthrow` for Result types instead of exceptions
- Import order: React → external libs → internal modules → types
- Use named exports, not default exports
- Every public API must have JSDoc comments

## Test Standards
- Use Vitest for unit tests
- Write tests in `__tests__/` next to source files
- Use describe/it blocks, not test()
- Mock external APIs with msw (Mock Service Worker)
- Aim for 80%+ branch coverage

## Database
- Use Prisma ORM
- All queries must use parameterized inputs
- Use transactions for multi-table operations
- Add indexes for all foreign keys

// VS Code: Settings for Copilot custom instructions
{
  "github.copilot.chat.customInstructions": {
    "path": ".github/copilot-instructions.md"
  }
}

# Bad prompt — too vague:
# Process the data

# Good prompt — specific and structured:
# Transform the CSV data into a list of dictionaries.
# The first row contains column headers.
# Handle quoted fields with embedded commas.
def parse_csv_to_dicts(csv_content: str) -> list[dict]:
    lines = csv_content.strip().split('\n')
    headers = lines[0].split(',')
    result = []

    for line in lines[1:]:
        if not line.strip():
            continue
        # Handle quoted fields
        fields = []
        current = ''
        in_quotes = False
        for char in line:
            if char == '"':
                in_quotes = not in_quotes
            elif char == ',' and not in_quotes:
                fields.append(current.strip())
                current = ''
            else:
                current += char
        fields.append(current.strip())
        # Copilot now completes the rest

# Template: "Implement [functionality] that [behavior] given [input] producing [output]"

# Example 1:
# Implement a retry wrapper that retries an async function up to 3 times
# with exponential backoff, given a function and its arguments,
# producing the result or throwing after all retries exhausted.

# Example 2:
# Implement a Redis-backed rate limiter that allows N requests per window,
# given a user ID and timestamp, producing a boolean indicating
# whether the request is allowed.

# Example 3:
# Implement a data validator that checks required fields exist
# given a JSON payload and a schema of required field names,
# producing a list of missing field names.

# Copilot generates tests from function signatures:

# Function to test:
def calculate_discount(price: float, code: str) -> float:
    discounts = {"SAVE10": 0.1, "SAVE20": 0.2, "WELCOME": 0.15}
    if code in discounts:
        return round(price * (1 - discounts[code]), 2)
    return price

# Copilot generates:
def test_calculate_discount():
    assert calculate_discount(100, "SAVE10") == 90.0
    assert calculate_discount(100, "SAVE20") == 80.0
    assert calculate_discount(100, "INVALID") == 100.0
    assert calculate_discount(0, "SAVE10") == 0.0
    assert calculate_discount(99.99, "WELCOME") == 84.99

# Copilot generates docstrings from function signatures:

def merge_sort(arr: list[int], ascending: bool = True) -> list[int]:
    # Copilot generates:
    """
    Sort a list of integers using the merge sort algorithm.

    Args:
        arr: The list of integers to sort.
        ascending: If True, sort in ascending order; otherwise descending.

    Returns:
        A new sorted list containing the same elements as the input.

    Time complexity: O(n log n)
    Space complexity: O(n)
    """
    if len(arr) <= 1:
        return arr
    mid = len(arr) // 2
    left = merge_sort(arr[:mid], ascending)
    right = merge_sort(arr[mid:], ascending)
    return merge(left, right, ascending)