GitHub Agentic Coding 101

What Is Agentic Coding?

Traditional coding assistants autocomplete your lines of code. Agentic coding goes much further. Instead of just suggesting the next few characters, an agentic AI can understand a high-level task, break it into steps, write code across multiple files, run terminal commands, check for errors, and iterate until the job is done.

Think of it like this: autocomplete is a spellchecker. Agentic coding is a collaborator sitting next to you who can write whole features, debug issues, and even submit pull requests while you sleep.

GitHub has built these agentic capabilities directly into GitHub Copilot, accessible through VS Code. As of 2026, Copilot has evolved from a code suggestion tool into an autonomous development partner that can plan, code, test, and iterate on your behalf.

What You Need to Get Started

Before diving in, make sure you have these basics covered:

Plans & Pricing

GitHub Copilot has five tiers. For individuals getting into agentic coding, the three that matter are Free, Pro, and Pro+. Here's what you get at each level:

What Are Premium Requests?

Premium requests power the advanced features: Chat, agent mode, code reviews, and access to premium AI models. Each prompt you send in agent mode counts as one premium request. The "standard" included model has a 0x multiplier, meaning it doesn't consume premium requests at all. Premium models cost 1x or more per prompt.

If you run out of premium requests, you can still use Copilot with the standard included models for the rest of the month. There are no automatic overage charges — you only pay extra if you explicitly enable a spending limit.

Setting Up Copilot in VS Code

Once you have VS Code and the Copilot extension installed, follow these steps:

The Three Modes

Copilot Chat in VS Code has three distinct modes. Understanding when to use each one is the most important thing you'll learn in this guide.

Agent Mode Deep Dive

Agent mode is where the real power of agentic coding lives. When you type a prompt in agent mode, here's what happens behind the scenes:

1. Copilot reads your prompt and determines what needs to be done.
2. It scans your workspace to find the right files and context — automatically. You don't need to tell it which files to look at.
3. It creates a plan of code changes and terminal commands needed to complete the task.
4. It makes the changes across however many files are necessary.
5. It runs terminal commands (with your approval) to install packages, compile, run tests, etc.
6. It checks the results — if there are errors, it reads them and tries to fix them automatically.
7. It iterates until the task is complete or it needs your input.

Example: Building a Feature

Say you type this prompt in agent mode:

Copilot will:

• Find your existing component files and stylesheets
• Create a theme context provider with light/dark state
• Add a toggle button component
• Update your CSS with dark mode variables
• Wire up localStorage persistence
• Apply the theme on initial page load
• If anything breaks, read the error and fix it

Terminal Commands & Approval

When agent mode needs to run a terminal command (like npm install or npm test), it will show you the command and wait for your approval before running it. This keeps you in control of anything that modifies your system.

Undo Support

Every action the agent takes is logged in the chat. You can undo individual changes or roll back the entire session. This makes it safe to experiment — if the agent goes in the wrong direction, just undo and try a different prompt.

The Coding Agent

The Coding Agent is a separate, more autonomous feature. While agent mode works inside your VS Code session interactively, the Coding Agent works in the background on GitHub without you being present.

How It Works

1. Assign a GitHub Issue to Copilot — on any issue in your repository, you can assign it to "Copilot" just like you'd assign it to a teammate.
2. Copilot creates its own environment — it spins up an isolated development environment using GitHub Actions.
3. It writes the code autonomously — reading your codebase, implementing the fix or feature, and running tests.
4. It opens a draft pull request — when it's done, you'll see a PR with all the changes for you to review.
5. You review and merge — just like any other PR. You can leave comments, and Copilot will respond and make changes.

Where You Can Trigger It

• GitHub Issues — assign an issue directly to Copilot
• Copilot Chat — delegate a task from your VS Code chat session
• GitHub CLI — trigger it from your terminal
• Third-party integrations — Slack, Microsoft Teams, Linear, Azure Boards

Safety Guardrails

GitHub has built-in protections for the Coding Agent:

• Only users with write access to the repo can trigger it
• It can only push to branches starting with copilot/ — it cannot push to main
• CI/CD workflows don't run until a human reviews and approves the code
• It always creates draft PRs, never auto-merges

AI-Powered Code Review

Copilot can also review your code, catching bugs, suggesting improvements, and enforcing coding standards. This works both on GitHub.com and directly in VS Code.

In VS Code

From the Source Control tab, you can ask Copilot to review your staged or unstaged changes. It will surface comments and suggestions inline and in the Problems tab, just like a human reviewer would leave comments on a PR.

On GitHub Pull Requests

When you create a pull request, you can add "Copilot" as a reviewer. It usually completes the review in under 30 seconds. Copilot leaves comments, not approvals, so it won't block your PR from being merged.

Advanced Review Features

• Agentic context gathering — the reviewer reads your whole project structure, not just the diff, to give more relevant feedback
• CodeQL & ESLint integration — combines AI reasoning with deterministic linting for high-confidence findings
• Incremental reviews — on follow-up pushes, it only reviews new commits, not the entire PR again
• "Implement suggestion" button — one click hands a review comment to the Coding Agent to fix it automatically

Skills, Custom Agents, and MCP

Beyond the built-in features, GitHub Copilot is extensible. You can add skills that teach it specialized capabilities, create custom agents with specific roles, and connect it to external tools using MCP (Model Context Protocol).

Agent Skills

Skills are "procedural knowledge packages" — think of them as recipes that teach Copilot how to do something specific. They're invoked as slash commands in the chat. Type / to see all available skills and prompts.

Examples of what skills can do:

• /webapp-testing for the login page — run a specialized testing workflow
• /github-actions-debugging PR #42 — debug a failing CI pipeline
• Custom skills your team creates for project-specific tasks

To create your own skills, place a SKILL.md file inside a folder under .github/skills/ in your repository. The skill loads on demand when the agent determines it's relevant.

Custom Agents

Custom agents let you set up different AI personas for specific development roles. Each agent gets its own instructions, tools, and behavior. Create them as .agent.md files in .github/agents/.

Examples of custom agents you might create:

• Security Reviewer — focused on finding vulnerabilities
• Docs Writer — specializes in generating documentation
• Test Engineer — writes and maintains test suites
• Architect — reviews design decisions and suggests patterns

You can also set up handoffs between agents, letting work flow from one specialized agent to another in a guided workflow.

MCP (Model Context Protocol)

MCP is an open standard that lets Copilot interact with external tools and services. When agent mode processes your prompt, it can call MCP tools to gather context (like querying a database schema) or perform actions (like deploying to a staging server).

Setting up MCP in VS Code:

• GitHub MCP Registry — browse and install curated MCP servers directly from VS Code, no configuration files needed
• Manual configuration — add MCP server settings to your VS Code settings or a workspace config file
• Community extensions — extensions like copilot-mcp provide a UI for discovering and managing MCP servers

Third-Party Coding Agents

With Pro+ or Enterprise subscriptions, you can also use third-party coding agents like Claude by Anthropic and OpenAI Codex directly within your GitHub workflow. You can assign issues to these agents just like you would to Copilot, and they'll autonomously write code and open pull requests.

Custom Instructions & Project Setup

One of the most impactful things you can do is give Copilot context about your project. Custom instructions tell Copilot about your coding standards, preferred patterns, tech stack, and project structure. This makes every interaction more relevant and accurate.

Quick Setup with /init

The fastest way to get started: type /init in the Copilot Chat input. It will analyze your project structure, detect existing conventions, and generate a comprehensive instructions file automatically. This is a great starting point that you can refine over time.

The Instructions File Hierarchy

Copilot reads instructions from several places, in order of priority:

AGENTS.md — The Universal Standard

AGENTS.md is an open standard developed by the Linux Foundation. It works across multiple AI tools — GitHub Copilot, Claude Code, Cursor, Gemini CLI, and more. If you only create one instructions file, make it AGENTS.md in your project root.

A good AGENTS.md includes:

• Your tech stack and key dependencies
• Coding standards (naming conventions, file organization)
• Build and test commands
• Architecture overview and key patterns
• Things to avoid (common pitfalls in your codebase)

copilot-instructions.md — Copilot-Specific

If you need Copilot-specific instructions (separate from what other AI tools see), create .github/copilot-instructions.md. VS Code automatically detects and applies this file to all chat requests. Both this file and AGENTS.md can coexist — Copilot uses instructions from both.

Path-Specific Instructions

For different rules in different parts of your codebase (e.g., stricter typing in your backend, different patterns in your frontend), create *.instructions.md files under .github/instructions/. Each file has a frontmatter block with an applyTo field that specifies which file paths the instructions apply to.

Essential Keyboard Shortcuts

These are the shortcuts you'll use every day. Learn the first four and you're already ahead of most users.

Tips & Best Practices

Writing Good Prompts

• Be specific about what you want, but don't over-specify how to do it. Let the agent choose the approach.
• Iterate, don't over-prompt. Short back-and-forth exchanges work better than one massive paragraph. If the first result isn't right, guide it with follow-up instructions.
• Give context about your project — or better yet, set up AGENTS.md so you don't have to repeat it every time.
• Use meaningful names in your code. Copilot's inline suggestions improve dramatically when your function and variable names are descriptive.

Working with Agent Mode

• Review the plan before it executes. What you intended and what Copilot understood may differ. Catching this early saves time.
• Start small. Begin with single-feature tasks and work up to larger ones as you get a feel for how the agent thinks.
• Use the right mode. Don't use agent mode for a quick rename — that's what Edit mode is for. Agent mode shines on multi-step, multi-file tasks.
• Your workspace matters. Open only the project you're working on. The agent searches your entire workspace for context, so extra open folders add noise.
• Check terminal commands before approving. The agent can suggest any terminal command. Read it before you click approve.

Getting Better Results

• Use # to reference context. In the chat, type # to attach specific files, symbols, selections, or even test failures as context for your prompt.
• Use / for slash commands. Type / to access skills, prompt templates, and built-in commands like /fix, /explain, and /tests.
• Select code before chatting. Highlight a block of code, then press Ctrl+I for inline chat — Copilot will focus on just that selection.
• Use commit message generation. In the Source Control tab, click the Copilot icon to auto-generate a commit message based on your staged changes.
• Let it debug. Paste error messages into the chat, or use the "Fix with Copilot" button that appears on diagnostics. It reads the error, finds the source, and suggests a fix.

Quota Management

• Agent mode uses more requests than Ask or Edit because it sends multiple follow-up requests internally. Use it when you need it, not for everything.
• The standard model is free. Prompts using the included model (0x multiplier) don't consume premium requests. Switch to it for routine tasks.
• Check your usage in your GitHub account settings under Copilot to see how many premium requests you've used this month.

Staying Safe

• Always review generated code. AI can produce code with subtle bugs, security issues, or outdated patterns. Treat it like a PR from a junior developer — review everything.
• Use version control. Always commit your work before starting a big agent mode session. This makes it easy to roll back if things go sideways.
• Don't share secrets. Avoid pasting API keys, passwords, or sensitive data into prompts. Copilot is an AI service, and your prompts are sent to the model.