Use GitHub Copilot to Supercharge Your Coding in VS Code

James Gress

Advanced Technology Center AI Lead — Accenture

This Slide Deck Was Created
Using GitHub Copilot

AI-Generated Code

CEO Insights & Where We Landed

The 2025 Hype: What Leaders Said

What They Said 2025
  • Dario Amodei (Anthropic): "90% of code AI-written in 3–6 months" (by Sep 2025) — within 12 months → essentially all code.
  • Mark Zuckerberg (Meta): "Most code AI-written within 12–18 months" of Jan 2025 → Jul–Oct 2026.
  • Marc Benioff (Salesforce): "May not hire any software engineers" in 2025 due to agentic AI.
  • Jensen Huang (NVIDIA): Advised young people to avoid programming in favor of biology, farming, or education.

The Mid-2026 Reality Check

Reality Check Mid-2026
  • Amodei's 90% call didn't materialize industry-wide by Sep 2025 — but Anthropic itself reportedly crossed 90% internally by early 2026.
  • Google hit ~75% by Apr 2026, ahead of Pichai's 2025 figures — directionally validating the curve even as timelines slipped.
  • Developer-demand paradox: the U.S. Bureau of Labor Statistics (BLS) projects +17% software-developer job growth 2023–2033. Most firms hired more engineers, not fewer.
  • The shift is real, the pace is slower. Industry avg ~15–25%; high-AI orgs 40–75%. Human review still gates most AI output.

Sources: BLS Occupational Outlook Handbook, Software Developers (2023–2033 projection) · Anthropic & Google figures per Apr 2026 company statements / press reporting · Industry averages from 2025–26 developer surveys (GitHub, Stack Overflow, DORA).

A Question for the Room

How long does it take a non-technical stakeholder to go from a napkin idea to a prototype?

Even a simple one — just a clickable mockup in Figma.

Microsoft Spark: Idea → Prototype in Minutes

Spark hands the power of building to anyone with an idea — describe it in plain language and get a working prototype back, no team or backlog required.

The Old Way ~6 Months
  • Write specs, secure budget, queue the backlog
  • Wait for design, dev, and review cycles
  • Ideas die waiting for engineering capacity
With Spark Minutes
  • Describe the idea → working prototype instantly
  • Iterate live, no hand-offs or sprint waits
  • Test, demo, and validate the same day

The shift: when prototyping is nearly free, the bottleneck becomes ideas, not engineering bandwidth.

Create Thoughtful Prompts

Structure Your Requests

  • Break down complex tasks into steps
  • Be specific about requirements
  • Provide examples of inputs/outputs

Good Practices

  • Follow coding standards in prompts
  • Include context about your project
  • Specify frameworks/libraries in use

Clear prompts = better results from Copilot!

Check Copilot's Work

Understanding & Review

  • Understand suggested code before merging
  • Ask Copilot Chat to explain if unsure
  • Review for functionality, security, readability

Automated Validation

  • Use automated tests to verify correctness
  • Run linting tools for code quality
  • Code scanning for security vulnerabilities

Remember: You're Responsible!

Copilot is powerful but can make mistakes — always validate before shipping.

FAQ: Does GitHub see your whole codebase?

Short answer To answer questions about your project, Copilot builds context from your code — including indexes that power features like @workspace and #codebase.

How it works

  • Cloud processing: repository contents can be processed in the cloud for suggestions and Copilot features, depending on your plan and settings.
  • Local processing: some IDE features run locally so code stays on your machine when configured for it.

FAQ: Privacy & Access

  • Indexing respects repository permissions and org policies; enterprise admins can configure or opt out.
  • Check your org settings and the Copilot privacy docs to control data use.

Practical tip: Use explicit scopes like #codebase, @github, or workspace context to limit what Copilot reads.

Time for Live Demo! 🚀

Switching to Hands-On Experience

Live demos in VS Code — what could go wrong? :) The remaining slides are reference material to revisit later.

Setting Up GitHub Copilot in VS Code

Quick Setup

  1. Install Extension: search "GitHub Copilot" in Extensions
  2. Sign In: Command Palette → GitHub Copilot: Sign In
  3. Start Coding: open any file and begin typing

Copilot is available on multiple GitHub plan tiers, and specific free/trial limits vary by account, org, and region.

Pop Quiz! 🤔

What is Ghost Text? 👻

Ghost Text & Code Completion

1function calculateTotal(items) {
2  return items.reduce((sum, item) => sum + item.price, 0);
3}
  • Ghost Text: gray suggestions that appear as you type
  • Tab accept  ·  Esc dismiss

Keyboard Shortcuts

ActionmacOSWindows/Linux
Accept suggestionTabTab
Dismiss suggestionEscEsc
Next suggestionOption + ]Alt + ]
Previous suggestionOption + [Alt + [
Trigger suggestionOption + \Alt + \
Open Chat viewCtrl + Cmd + ICtrl + Alt + I
Inline ChatCmd + ICtrl + I

Another Pop Quiz! 🤔

Do you know what these are?

Context Creep 🌊    Context Confusion 😵‍💫

Context Creep & Context Confusion

Context Creep 🌊

  • Conversations gradually drift off-topic
  • Irrelevant info accumulates over time
  • AI gets "distracted" by earlier discussions

Context Confusion 😵‍💫

  • AI mixes up different topics/projects
  • Wrong assumptions from earlier context
  • Reduced accuracy and relevance

Start Fresh Chats

Why Start New

  • Avoid context confusion & topic drift
  • Get focused suggestions

When to Start New

  • Switching files/projects
  • Different programming language
  • New feature vs. bug fix
  • Code review vs. implementation

How: Click "New Chat" or Ctrl/Cmd + L

Ask Mode — Copilot Chat

Access

  • Chat view: Ctrl + Cmd + I (mac) / Ctrl + Alt + I
  • Inline Chat: Cmd/Ctrl + I

Examples

  • Explain this code
  • Generate unit tests
  • How do I run this code?
  • What are the options for pip install?

Chat History Tip ⬆️

Press the ↑ arrow in the chat input to quickly recall your previous chat messages.

Benefits

  • Quickly repeat or modify previous questions
  • No need to retype complex queries
  • Navigate through your recent history

Pro Tip: Iterate on questions without starting over.

Copilot Chat Actions

After getting a response, you can:

  • 📋 Copy — copy response to clipboard
  • 💾 Insert at Cursor — add code at cursor position
  • 📝 Insert in New File — create a new file
  • 💻 Insert in Terminal — run command in terminal
  • 🔄 Apply in Editor — replace/modify existing code

Pro Tip: Hover over code blocks in chat to reveal action buttons.

Inline Chat — Quick In-Place Edits

Access

  • Press Cmd/Ctrl + I in the editor
  • Select code first to scope the edit to that range
  • For larger or multi-file changes, use Agent

Examples

  • "Add error handling"
  • "Convert to async/await"
  • "Add TypeScript types"
  • "Refactor this function"

Built-in Chat Participants (@)

Available Participants

  • @workspace — reason over your entire codebase
  • @vscode — VS Code settings & features
  • @terminal — command-line help
  • @github — GitHub platform, web search & knowledge bases

Examples

  • "@workspace find all TODO comments"
  • "@vscode how do I configure extensions?"
  • "@terminal run the build script"

Agent Mode — Autonomous Multi-File Tasks

Access

  • Open the Chat view and select Agent from the Agent dropdown (Ask · Agent · Plan)

What it does

  • Plans the work, edits multiple files, and runs terminal commands
  • Self-corrects from errors and test failures, iterating to completion
  • Invokes tools & MCP servers; you approve actions along the way
  • Now covers the tasks that used to live in Edit mode

Examples: "Add a new component and wire it up" · "Migrate this feature and run the tests"

Plan Mode: Strategic Planning

What is Plan Mode?

  • AI-assisted planning for complex development tasks
  • Breaks large projects into manageable steps
  • Produces a reviewable implementation roadmap before code is written

When to Use

  • Large multi-component features
  • System architecture / major refactors
  • Integration & migration projects

Plan Mode Workflow

  1. Define Scope: describe requirements in detail
  2. AI Analysis: Copilot reviews codebase & requirements
  3. Strategic Plan: generates a step-by-step plan
  4. Task Breakdown: creates actionable tasks
  5. Review & Approve: you refine before execution
Create a plan for a user authentication system with:
- Email/password login
- Social OAuth integration
- Password reset
- JWT token management
- Database schema design

Plan Mode vs Other Modes

AspectPlan ModeAsk / Agent
ScopeStrategic planningImmediate execution
HorizonDays / weeksMinutes / hours
OutputDetailed roadmapCode implementation
Best ForProject planningCode development

Copilot Modes: Overview

GitHub Copilot offers distinct modes for different scenarios:

  1. Ask Mode — questions & explanations
  2. Agent Mode — autonomous multi-file operations (now covers the former Edit mode)
  3. Plan Mode — strategic project planning

Quick in-place edits use Inline Chat (Cmd/Ctrl + I). Let's explore how they differ and when to use each…

Ask vs Agent Modes

FeatureAsk ModeAgent Mode
PurposeInfo & explanationsAutonomous multi-file changes
AccessChat view (Ask)Chat view (Agent dropdown)
ScopeQuestions & learningEntire workspace
OutputText + examplesCode edits, commands, iterations
Best ForLearning, debuggingFeatures, refactors, migrations

Agent vs Plan Modes

FeatureAgent ModePlan Mode
PurposeAutonomous multi-file workStrategic planning
AccessAgent dropdown → AgentAgent dropdown → Plan
ScopeEntire project/workspaceFull project lifecycle
OutputWorkflows & changesImplementation roadmap
Best ForFeatures, refactorsLarge projects, migrations

All Three Modes: Quick Reference

AskAgentPlan
ComplexityLowMed–HighHigh
SpeedInstantModeratePlanning
InteractionConversationalAutonomousStrategic
Learning CurveEasyModerateAdvanced

Pro Tip: Ask to understand → Agent to build & refactor → Plan for big initiatives.

Repository Custom Instructions

Create: .github/copilot-instructions.md  (repo-wide, always applied)

- Use TypeScript for new files
- All functions include JSDoc comments
- Follow company naming conventions
- Always add error handling
- Write unit tests for new functions
  • Team-wide consistency & project-specific guidance
  • Version-controlled with your code
  • AGENTS.md is also supported as an open, cross-tool standard

Settings Locations

Personal (User Settings)

  • macOS: ~/Library/Application Support/Code/User/settings.json
  • Windows: %APPDATA%\Code\User\settings.json
  • Linux: ~/.config/Code/User/settings.json

Project (Team Settings)

  • .vscode/settings.json
  • Command Palette → "Preferences: Open User Settings (JSON)"

Copilot Prompt Files

Create: .github/prompts/<name>.prompt.md

Example: .github/prompts/test-generator.prompt.md

---
mode: agent
description: Generate comprehensive unit tests
---
Generate unit tests for the selected function:
- Happy path scenarios
- Edge cases and error conditions
- Mock external dependencies
- Use the Jest testing framework

Usage: type /test-generator in Copilot Chat

Prompt File Example: Code Review

.github/prompts/code-review.prompt.md

# Code Review Assistant
Review the selected code for:
- Security vulnerabilities and best practices
- Performance optimizations
- Maintainability and readability
- Adherence to project coding standards

Usage: /code-review + select code

Prompt File Example: Architecture Docs

.github/prompts/arch-docs.prompt.md

# Architecture Documentation Generator
Update architecture documentation for:
- System design patterns used
- Component relationships and dependencies
- Data flow and API contracts
- Deployment and scaling considerations

Usage: /arch-docs + relevant files

AI-Readable Documentation

Why Diagrams Matter

  • Visual context AI can parse and understand
  • Structured format (Mermaid) enhances comprehension
  • Living documentation that stays in sync with code
User Request→ Authentication→ Data Processing→ Database Query→ Response

AI-Readable Documentation

Best Practices

  • Use standardized formats (Mermaid, PlantUML)
  • Include clear labels and descriptions
  • Keep diagrams close to relevant code
  • Add comments explaining relationships

Result: Copilot understands your architecture and suggests better code!

Path-Specific Instructions

Create: .github/instructions/<name>.instructions.md

---
applyTo: "src/**/*.ts"
---
# TypeScript Code Style
- Use camelCase for variables and functions
- Add explicit types for all parameters
- Include JSDoc comments for public functions
- Keep components under 200 lines

The applyTo glob scopes these rules to matching files automatically.

Custom Agents

Create: .github/agents/<name>.agent.md (formerly "custom chat modes")

---
description: Expert code reviewer
tools: ['codebase', 'search']
---
You are an expert code reviewer. Focus on:
- Security vulnerabilities
- Performance optimizations
- Maintainability & best practices
Always provide specific suggestions with examples.

Usage: select your agent from the Chat view Agent dropdown

Another Pop Quiz! 🤔

What are Sparkles? ✨

Sparkles Explained ✨

Sparkles are the ✨ icons in VS Code that signal:

  • AI-powered suggestions are available
  • Copilot can help with the current context
  • Interactive AI features you can click or invoke

Custom Instructions in Settings

  • VS Code Settings → GitHub Copilot
  • Project-specific .vscode/settings.json
{
  "github.copilot.chat.commitMessageGeneration.instructions": [
    { "text": "Use conventional commit format" }
  ],
  "github.copilot.chat.codeGeneration.instructions": [
    { "text": "Always add TypeScript types" }
  ]
}

Configuring Commit Messages

{
  "github.copilot.chat.commitMessageGeneration.instructions": [
    {
      "text": "For Slides changes, describe the change in
       content — not the technical implementation."
    }
  ]
}
  • Project-specific AI behavior tailored to your workflow
  • Team consistency through shared configuration

Where Project Settings Live

your-project/
├── .vscode/
│   └── settings.json
├── .github/
│   ├── copilot-instructions.md
│   ├── instructions/
│   ├── prompts/
│   └── agents/
└── other-files...

Enhancing Copilot with Context

Three ways to enhance your interactions:

  1. Add Context (#) — files, selections, symbols, terminal output
  2. Use Participants/Extensions (@) — chat participants & extensions
  3. Run Commands (/) — built-in Copilot commands & prompt files

# context  ·  @ participants  ·  / commands

Adding Context (#)

  • #file:README.md — include a specific file
  • #<symbol> — reference a function, class, or variable
  • #selection — current code selection
  • #codebase — search the whole project for context
  • #terminalLastCommand — last terminal command & output

More precise context → more accurate, relevant suggestions.

Using Participants & Extensions (@)

  • Built-in: @workspace, @vscode, @terminal, @github
  • Extension-provided participants appear in autocomplete
  • MCP servers add tools you can invoke from chat

Type @ in chat to see every participant available in your install.

Running Commands (/)

  • /explain — explain selected code
  • /fix — fix issues in code
  • /tests — generate test cases
  • /doc — generate documentation
  • /new — scaffold new files/projects

Your custom prompt files also show up here as /<name>.

Combining #, @ & /

Fix issues in a specific file:

/fix #file:src/components/Button.js

Generate tests for the selection:

/tests #selection

Explain with full codebase context:

@workspace /explain #codebase

MCP Servers: Connect External Services

The Model Context Protocol (MCP) lets Copilot connect to external tools & data sources.

Popular MCP Servers

  • GitHub — repositories, issues, PRs, Actions
  • Atlassian — Jira & Confluence
  • Playwright, databases, and many more

Setting Up MCP Servers

  1. Add the server config in .vscode/mcp.json or through the MCP tooling UI in your editor
  2. Configure authentication (OAuth or API keys/tokens)
  3. Enable it for Agent mode and start invoking its tools

Tooling and one-click installs vary by editor version and extension capabilities.

Smart Detection vs Explicit Tools

Copilot can auto-detect intent

"Create a bug ticket for the login timeout issue"
"Show me open issues in the frontend repo"
"Update ticket DEV-456 status to In Progress"

Or invoke tools explicitly

#getJiraIssue
#editJiraIssue

MCP in Action: Real Workflows

Bug discovery & ticket creation

Create a high-priority Jira bug for the login
timeout in the authentication module

Pull down issues to work on

Show open issues assigned to me in the frontend repo
List my current sprint tasks with status "To Do"

Update progress

Set AUTH-123 to "In Progress" and comment
"Started investigating timeout configuration"

Agent Customizations

Tailoring Copilot to your workflow

Agent Customizations: Overview

These settings help you shape Copilot from a general assistant into a tool that fits your work style, team practices, and project context.

What they control
  • Which capabilities the agent can use
  • What context and instructions it sees
  • How specialized it behaves for specific tasks
  • Which external systems it can connect to
Why they matter
  • More consistent responses
  • Better domain-specific behavior
  • Safer and more controlled automation
  • Fewer repeated instructions in every prompt

Plugins

Plugins expand Copilot's capabilities by adding new tools, integrations, or features that the agent can use during a task.

  • Extend the assistant beyond core IDE behavior
  • Add domain-specific tools or integrations
  • Improve workflows for design, docs, tickets, APIs, or testing

Think of them as add-ons: more power, but only when relevant.

MCP Servers

Model Context Protocol (MCP) servers let Copilot connect to external systems in a standard, reusable way.

  • GitHub: repo details, issues, PRs, and actions
  • Jira / Confluence: project and ticket context
  • Databases and APIs: real operational data

Benefit: the agent can work with live tools instead of only reading local code.

Skills

Skills are reusable capabilities that teach the agent how to perform a certain kind of work well.

  • Examples: code review, architecture analysis, test generation, onboarding tasks
  • Help the agent act with a clear specialty or playbook
  • Reduce repetition across prompts and project workflows

Goal: consistent expertise, not random guesswork.

Instructions

Instructions are the long-term guardrails for Copilot.

  • Set coding standards and naming conventions
  • Specify how to write tests and handle errors
  • Define preferred project patterns and documentation style
- Use TypeScript for new files
- Add JSDoc for public APIs
- Always validate with tests
- Follow team naming conventions

Result: less drift and more predictable output.

Agents

Agents are specialized assistant profiles built for a specific job or team workflow.

  • Can be designed for code reviews, triage, testing, or operations
  • Have a narrower focus than a general-purpose chat assistant
  • Use selected tools and instructions to stay on task

Best use: repeatable, specialized work rather than open-ended brainstorming.

Hooks

Hooks trigger automation when events happen in your workflow.

  • Run checks before commits or pushes
  • Enforce project actions when files change
  • Connect Copilot to a broader automation pipeline

Example: validate code quality or generate notes immediately after a file is updated.

Tools

Tools are the actions Copilot is allowed to take. They define what the agent can read, edit, run, and verify.

  • Search and read files
  • Modify code and create files
  • Run terminal commands and tests
  • Access workspace or connected services

Rule: the more precise the tool access, the more controlled and reliable the automation.

Why These Matter

The Big Idea
  • Plugins add new capabilities
  • MCP Servers connect external systems
  • Skills package expertise
  • Instructions define behavior
  • Agents specialize the assistant
  • Hooks automate responses to events
  • Tools grant execution power

Takeaway: Copilot becomes much more useful when you give it the right context, constraints, and tools.

GitHub Copilot Coding Agent

What is it?

  • Autonomous agent that completes entire features
  • Assign a GitHub issue directly to Copilot
  • Works independently in a secure cloud environment

How it works

  1. Assign: hand an issue to Copilot (or ask in chat / CLI)
  2. Analyze: reviews requirements & codebase
  3. Implement: spins up a cloud env (GitHub Actions), writes code, runs tests
  4. Draft PR: opens a pull request and tags you for review

GitHub Copilot CLI

A powerful AI agent — right in your terminal

Copilot CLI: AI in Your Terminal

What is it?

  • A terminal-based AI agent for coding, troubleshooting, and workflow automation
  • Can write and debug code, run commands, and work with GitHub artifacts
  • Works on macOS, Linux, and Windows (PowerShell / WSL)

Install & start

# Install the standalone CLI (example)
npm install -g @github/copilot

# Start an interactive session
copilot

Copilot CLI: Two Ways to Use It

Interactive

copilot
# Chat, iterate, and steer. Use the agent selector for planning workflows.
# Common features may include /model, /mcp, /context, and /compact

Programmatic (headless)

copilot -p "Show this week's commits and summarize them" \
  --allow-tool='shell(git)'

# Run in an isolated cloud sandbox
copilot --cloud

Copilot CLI: Example Tasks

# Local code changes
"Change the background-color of H1 headings to dark blue"

# Work an assigned issue end-to-end
"I've been assigned issue #1234 — start it in a new branch"

# Make changes and open a PR
"Add a user-info.js script and open a pull request"

# Git help
"Revert the last commit, leaving the changes unstaged"

Auto-compaction keeps long sessions going; /sandbox enable restricts local access.

Thank You! 🙏

James Gress · AI Lead @ Accenture

Connect with James Gress QR code

jmgress.github.io/githubcopilot

James Gress · AI Lead @ Accenture · jmgress.github.io/githubcopilot
1 / 1

Speaker notes

Keyboard Shortcuts

→ Space PgDnNext slide
← PgUpPrevious slide
Home / EndFirst / last slide
SToggle speaker notes
FToggle fullscreen
?Toggle this help

Press any key to close.