GitHub Copilot on KTDEVX

Basic GitHub Copilot Usage in VS Code

ktdevx@gmail.com (Kaito Takemura) — Wed, 02 Sep 2026 00:00:00 +0900

GitHub Copilot in Visual Studio Code (VS Code) can help you write, investigate, and modify code with AI assistance.

This article explains how to set up GitHub Copilot in VS Code and try its basic features, including code completion and chat. Always review generated code and run tests when appropriate.

# Prerequisites

Prepare the following:

VS Code
A GitHub account
A plan or free allowance that supports GitHub Copilot

Use a recent version of VS Code when possible. GitHub Copilot plans and usage limits may change, so check the GitHub Copilot plans page for the latest information.

# Install the GitHub Copilot extension

Start VS Code.
Select the Extensions icon in the Activity Bar.
Enter GitHub Copilot in the search box.
Select the GitHub Copilot extension published by GitHub.
Select Install.

Depending on the version, GitHub Copilot Chat may be included in the same extension. Check the publisher and description in the search results before installing an extension.

After installing the extension, VS Code may ask you to sign in to your GitHub account.

Start GitHub sign-in from the status bar or the Accounts menu in VS Code.
When your browser opens, sign in to your GitHub account.
Authorize VS Code.
Return to VS Code and confirm that the Accounts menu shows you are signed in.

If sign-in does not work, restart VS Code and check the Accounts menu again. If you use an organization account, check whether an administrator has restricted GitHub Copilot access.

# Use code completion

Code completion suggests continuations based on the code and comments you are entering. For example, enter the following comment in a Python file:

# Return the sum of all numbers from 1 through the given number

Start entering a function on the next line. A suggested implementation may appear as faint text. To accept the suggestion, press Tab in the usual configuration. To dismiss it and continue typing, press Esc.

When a suggestion does not match your goal, make the comment more specific. Including argument names, the return value, and whether error handling is required can make your intent clearer.

# Review multiple suggestions

When a suggestion is displayed, other suggestions may be available. The keyboard commands for switching suggestions can vary with the VS Code version, extension version, and keyboard layout.

To view available commands, right-click in the editor and inspect the GitHub Copilot menu, or search for Copilot in the Command Palette (Ctrl+Shift+P). Before accepting a suggestion, review its logic, error handling, and treatment of external input.

# Ask questions in Copilot Chat

Copilot Chat lets you ask questions about code and errors in natural language.

Open Chat from the Activity Bar.
Enter a question in the input box.
Add relevant files or code as context when necessary.
Send the question and review the answer.

For example, enter a specific request such as:

Explain what this function does. Also check whether it handles an empty input safely.

Do not assume that the answer is correct. Check that the explanation matches the actual code. Including the project goal, libraries in use, and relevant error messages can make your question more useful.

# Choose Ask, Plan, or Agent mode

The mode selector in Copilot Chat lets you choose an interaction style for your task. The available modes and their names may vary with the VS Code and Copilot versions.

## Ask mode

Ask mode is for asking questions about code, explaining behavior, and investigating errors. It is generally useful when you want an answer or code example without asking Copilot to modify files.

For example, you could enter:

Find the files that handle authentication in this project and explain the flow.

## Plan mode

Plan mode is for organizing the investigation and implementation steps before making changes. For work involving several files, creating a plan first can make the target files, sequence of changes, and verification steps easier to review.

Review the plan and provide any corrections before asking Copilot to implement it. Creating a plan does not mean that the code has been changed correctly.

## Agent mode

Agent mode lets Copilot work through a task step by step, which can include inspecting files, editing code, and running tests or commands. For example, you could ask:

Add input validation to the user registration form and create tests for it.

Agent mode may change files or run commands. Review any confirmation request before allowing the action, then review the diff, test results, and commands after it finishes. As a simple rule, use Ask for a small investigation, Plan for work that needs preparation, and Agent for a clearly defined implementation task.

# Choose a model

The model picker in Chat lets you switch between available AI models. Models can differ in response speed, strengths, context handling, and how usage is calculated.

Consider the balance between the task and usage when choosing a model:

Choose a standard or faster model for short explanations and simple questions.
Choose a model with stronger reasoning for complex design, debugging, or multi-file changes.
When you want to reduce usage, check the multiplier or description shown next to the model name.

The available models and multipliers depend on your Copilot plan, organization settings, and the current service. A particular model may not always be available, so use the latest information shown in the Chat model picker.

# Choose thinking effort

Models that support reasoning may provide a thinking effort setting. A higher effort can make it easier to work through a complex problem, but it may take longer and use more of your allowance.

Low effort: checking terminology, short explanations, and simple changes
Medium effort: ordinary debugging and test creation
High effort: complex design, isolating a difficult cause, and broad changes

Not every model or plan provides a thinking effort setting. Use it when the selector is available and match it to the complexity of the task. A higher effort does not guarantee a correct answer, so review the generated result.

# Understand credits

Credits are a way to measure AI usage in GitHub Copilot. The amount available each month depends on the plan, and the amount consumed can vary by the request, model, and feature. An advanced model or task may consume more than one credit for a single request.

Credits are not a score for code quality or correctness. The quantity and terminology shown in VS Code can also vary with your subscription and GitHub’s billing system. Check your account settings or usage page for the remaining amount and reset date. When appropriate, choose a lower-cost model or Ask mode to manage usage.

# Explain or modify selected code

You can ask questions about a selected section of code.

Select the code you want to understand in the editor.
Right-click and open the GitHub Copilot menu.
Choose an action such as explaining the code, modifying it, or creating tests.
Review the proposed change.

When asking for a modification, state the goal precisely. For example:

Add input validation to this code. Keep the existing return value format unchanged.

Review the diff before applying the proposed change. If the change is broad, inspect each part and undo anything unnecessary.

# Use inline chat

Inline chat lets you make a request about the current code without leaving the editor.

Select the target code in the editor.
Search for Copilot in the Command Palette and choose the command that starts inline chat.
Enter the change you want.
Review the displayed diff, then apply or cancel it.

Include both the scope and constraints in your request. For example: Modify only this function and do not change the name of its public API.

# Review and apply suggestions

Use the following process when adopting a GitHub Copilot suggestion:

Review the diff before and after the change.
Confirm that the generated logic matches your request.
Check types, return values, exceptions, and boundary cases.
Run tests and static analysis.
Save and commit the change only after it passes your checks.

When fixing an error, investigate the error message instead of hiding it. Do not assume that an error is resolved just because Copilot suggested a change. Run the application or tests to verify the result.

# Things to keep in mind

## Do not enter sensitive information

Do not enter API keys, passwords, personal information, customer information, or confidential company information in prompts or chat. Replace real values with a minimal example that does not expose sensitive data.

## Verify generated code

Generated code may contain errors, vulnerabilities, or inefficient processing. Review code involving authentication, authorization, input validation, encryption, and database operations against official documentation and test results.

## Check licenses and dependencies

If you use generated code in publicly distributed software, check the project’s license and the terms of dependent libraries. Investigate any concerns about the origin or usage conditions of code before adopting it.

## Keep changes small

Small, focused requests make generated diffs easier to review than a request to generate a large feature all at once. Consider working on a Git branch so you can restore the previous state when necessary.

# Summary

In VS Code, GitHub Copilot can help with code completion, questions in chat, explanations and modifications of selected code, and inline chat.

Copilot is a development aid, not a replacement for review. Check the request and the diff, and use tests, static analysis, and security reviews as part of your workflow.

For detailed setup instructions, see Setting up GitHub Copilot (GitHub Docs).

How to Configure GitHub Copilot Context Files

ktdevx@gmail.com (Kaito Takemura) — Wed, 02 Sep 2026 00:00:00 +0900

GitHub Copilot can use more than the file you have open or the code you are typing. It can also use instructions stored in your project when generating answers and changes. Keeping project rules in context files reduces the need to repeat the same explanation in every request.

This article explains the main types of context files available in Visual Studio Code (VS Code) and how to configure them in a repository. The supported files and labels can vary by Copilot version and agent. Check the latest official documentation when you use these features.

# Prerequisites

Prepare the following:

VS Code
A GitHub account with access to GitHub Copilot
A project managed with Git

This article uses PROJECT_ROOT to represent the root directory of the project. If you already opened the project in VS Code, replace PROJECT_ROOT with its actual location.

# Types of context files

Use the following files for different types of shared project instructions in VS Code.

File	Main purpose
`.github/copilot-instructions.md`	Instructions for the entire repository
`.github/instructions/NAME.instructions.md`	Instructions for specific files or directories
`AGENTS.md`	Instructions for an agent, applied to work under its directory

Use copilot-instructions.md for the project purpose and common development rules. Changing its file name or location can prevent it from being discovered automatically.

Path-specific instruction files use applyTo in front matter to define their targets. For example, the following applies to all TypeScript files:

---
applyTo: "**/*.ts,**/*.tsx"
---

AGENTS.md is useful when different directories in a monorepo need different rules. Support can vary by agent and execution environment, so check the documentation for the agent you use.

# Add repository-wide instructions

Start by writing the rules that should be shared across all work in .github/copilot-instructions.md.

## Create the file

Create the following directory and file at the project root:

PROJECT_ROOT/
└── .github/
 └── copilot-instructions.md

Keep the instructions short and specific. For example:

# Project instructions

- This project is a multilingual website built with Hugo Extended.
- Content is managed separately in content/ja/ and content/en/.
- When changing a blog post, check both the Japanese and English versions.
- Run hugo --minify after changes to verify the build.
- Do not edit generated public/ or resources/_gen/ files directly.

Include the project purpose, the role of important directories, required commands, and rules to follow when making changes. Focus on information that is needed repeatedly instead of copying a long document into the file.

# Add path-specific instructions

When rules differ by language or directory, create instruction files in .github/instructions/.

For example, save Markdown rules in the following location:

PROJECT_ROOT/
└── .github/
 └── instructions/
 └── markdown.instructions.md

---
applyTo: "**/*.md"
---

- Use short headings that describe the content.
- Put commands in code blocks.
- Include a way to verify each procedure after it runs.

To target only one directory, use a glob such as content/en/**/*.md. Separate multiple file extensions with commas in the applyTo value.

When a repository-wide instruction and a path-specific instruction both match a request, both may be used. Conflicting instructions can reduce the quality of answers and changes, so keep common rules and local rules clearly separated.

# Use AGENTS.md

Use AGENTS.md for rules specific to an agent’s work. Put it at the repository root to provide instructions for agent work across the project.

PROJECT_ROOT/
└── AGENTS.md

In a monorepo, place additional files closer to the subproject when its rules differ:

PROJECT_ROOT/
├── AGENTS.md
└── packages/
 └── web/
 └── AGENTS.md

For work in a subdirectory, the nearest AGENTS.md takes precedence. Keep the root rules and subproject rules consistent where they overlap.

AGENTS.md is not necessarily applied in the same way to every Copilot feature. Code completion, Chat, Agent, GitHub.com Cloud Agent, and Code Review can support different customization types.

# Write useful instructions

Include information that helps Copilot make verifiable decisions:

The project purpose and main technologies
The role of directories and files
Coding conventions and naming rules
Test, build, and static analysis commands
Files that must not be changed and compatibility requirements
Checks to perform after making changes

For example, instead of writing “make the code clean,” write “do not rename the public API and run the existing tests.” Split instructions into small bullet points and state important conditions and exceptions.

# Check whether instructions are applied

After saving the file, open Copilot Chat in VS Code and check whether the instructions are being used.

Open the project root in VS Code.
Save an instruction file such as .github/copilot-instructions.md.
Ask Chat about the project structure or the checks required after a change.
Check whether the answer reflects the content of the instruction file.
If you ask an Agent to work, review the changed files and commands it ran.

To check path-specific instructions, ask about a file that matches applyTo. For example, if instructions target Markdown files, ask about headings or links in a Markdown article.

Seeing an instruction file in the context does not guarantee that the answer is correct. Check the response references or Agent debug logs, and compare the result with a request that states the relevant requirement explicitly.

# Troubleshoot missing instructions

If a context file does not appear to be used, check the following:

Confirm that the file name is copilot-instructions.md or follows the NAME.instructions.md pattern.
Confirm that copilot-instructions.md is inside the repository’s .github directory.
Confirm that path-specific files are inside .github/instructions.
Confirm that the applyTo glob matches the target file path.
Confirm that the repository root is open in VS Code.
Update VS Code and GitHub Copilot when possible.
If you use an Agent, inspect the Agent debug logs for loaded files.

When you open only a subdirectory of a monorepo, a setting for discovering customizations in parent repositories may affect the result. The setting name and default value can change with VS Code versions, so check the official documentation.

# Things to keep in mind

## Keep instructions short and specific

Too many instructions can hide important conditions or create conflicts. Separate repository-wide rules from rules for a particular type of file.

## Verify generated results

A context file does not guarantee correct code. Review the diff, types, exception handling, boundary cases, and security concerns, then run tests and static analysis.

## Do not include sensitive information

Do not put API keys, passwords, personal information, customer information, or confidential company information in context files. When a repository is shared, other people or services may be able to access the content.

## Check feature support

The Copilot features that use a context file depend on its type. VS Code, GitHub.com, Cloud Agent, and Code Review may not behave the same way. Check the official documentation for the environment you use.

# Summary

GitHub Copilot context files can reduce the need to repeat a project’s purpose, development rules, and verification steps.

Put shared rules in .github/copilot-instructions.md.
Put file- or directory-specific rules in .github/instructions/*.instructions.md.
Put agent-specific rules in AGENTS.md.
Keep instructions short and specific, and always verify generated results.

For details, see Repository custom instructions for GitHub Copilot (GitHub Docs) and Copilot customization in VS Code.

How to Create and Use Agent Skills in VS Code

ktdevx@gmail.com (Kaito Takemura) — Wed, 02 Sep 2026 00:00:00 +0900

Agent Skills let AI agents such as GitHub Copilot use additional procedures and decision criteria for specialized tasks. They make a repeatable workflow available for tasks such as investigation, editing, and testing.

This article explains how to create a project Agent Skill in VS Code and use it in chat. The hands-on example creates a release-notes skill that drafts release notes from a repository’s changes.

# Prerequisites

Prepare the following:

VS Code with access to GitHub Copilot Chat and Agent features
A GitHub account that can use GitHub Copilot
A Git repository where you can add a skill

Menu names and available models may vary by version and subscription.

# What are Agent Skills?

Agent Skills are an open standard that can be used by multiple AI agents. An Agent Skill is a specialized workflow that an AI agent loads when it is relevant. This article uses the skill through the GitHub Copilot extension for VS Code. For a project skill, a common location is:

.github/skills/<skill-name>/SKILL.md

The YAML front matter in SKILL.md must contain at least these fields:

name: The identifier of the skill. Use lowercase letters, numbers, and hyphens only, and make it match the parent directory name.
description: A description of what the skill does and when to use it.

The body describes the procedure, constraints, and verification steps. You can also add scripts, examples, and reference files in the same directory.

Custom instructions and Agent Skills serve different purposes. Custom instructions are useful for continuously applying project conventions. Agent Skills are useful for loading task-specific procedures, such as testing, debugging, or deployment, when they are needed.

# Prepare the hands-on exercise

Open a practice Git repository in VS Code. If you use an existing repository, commit its current state first so that generated changes are easy to review.

Create the following directory from the project root:

.github/
└── skills/
 └── release-notes/
 └── SKILL.md

You can create it in the Explorer or run these commands in PowerShell:

New-Item -ItemType Directory -Force .github\skills\release-notes
New-Item -ItemType File -Force .github\skills\release-notes\SKILL.md

# Write the skill

Open SKILL.md and paste the following content:

---
name: release-notes
description: Create a release notes draft from the changes in the current Git repository. Use when preparing a release summary, changelog entry, or pull request release notes.
---

# Release notes

Create a concise release notes draft from the current repository changes.

## Procedure

1. Inspect the current branch and the changes compared with the default branch.
2. Read relevant commit messages and changed files. Do not include secrets or full sensitive values in the draft.
3. Group changes into Added, Changed, Fixed, and Removed. Omit empty groups.
4. Write each item for a user who needs to understand the effect of the change.
5. Ask a clarifying question when the comparison branch or release scope is unclear.
6. Do not edit project files unless the user explicitly asks for a file change.

## Output format

Return the following sections:

- A one-sentence summary
- A Markdown release notes draft
- A short list of files or commits inspected
- Open questions and verification items

Keep the draft factual. Do not invent issue numbers, performance results, compatibility claims, or breaking changes.

Make the description specific about both the capability and the requests that should activate it. An unclear description makes automatic selection less reliable. Use the body to define the order of work and output format.

It is also useful to describe what the agent must not do. This example prevents file edits unless the user explicitly asks for them. For skills that run commands or edit files, document the scope, verification steps, and treatment of secrets.

# Check that VS Code recognizes the skill

Save SKILL.md and open the Chat view. Type / in the input field. release-notes should appear in the list of available skills.

If it does not appear, check the following:

Confirm that VS Code opened the repository root folder.
Confirm that the file is named exactly SKILL.md.
Confirm that name: release-notes matches the release-notes directory.
Make sure name does not contain uppercase letters, slashes, colons, or dots.
Confirm that the front matter starts and ends with ---.
Close and reopen the Chat view to refresh the skill list.

Agent Skills can be loaded automatically when they are relevant to a request. To guarantee that this skill is used, select it explicitly with /release-notes.

# Run the skill

In a repository with changes, enter this prompt in Chat:

/release-notes Create a draft for the next release from the changes on the current branch.

Review the result carefully:

Is every described feature present in the actual diff?
Are changes grouped correctly as Added, Changed, Fixed, or Removed?
Are breaking-change or compatibility claims supported by evidence?
Does the output contain any secrets or personal information?
Are remaining verification items clearly identified?

You can also test automatic selection without using /release-notes:

Summarize the changes for the next release as user-facing release notes.

If the skill is not selected automatically, make its description more specific or invoke it with the slash command. After changing the skill body, start a new chat before testing again.

# Use additional files

For a longer workflow, split supporting material into files in the skill directory instead of putting everything in SKILL.md.

.github/skills/release-notes/
├── SKILL.md
├── examples/
│ └── release-notes.md
└── templates/
 └── changelog.md

Reference additional files with relative links from SKILL.md:

Use the [changelog example](./templates/changelog.md) as the template.

Referencing a file tells the agent where to find the material when it needs it. If you include a script, review its input validation, network access, and file deletion behavior before using it.

# Agent Skill design guidelines

## Keep one purpose

A skill that combines testing, deployment, and release-note writing will have vague activation conditions and procedures. Split different goals into separate skills so only the relevant workflows are combined.

## Define the procedure and completion criteria

Phrases such as “check appropriately” are difficult to follow. Specify commands, files to inspect, output format, and what to do when a step fails.

## Limit permissions

Agent Skills describe procedures, but the agent may run commands or modify files while following them. For deletion, external communication, or deployment, document the scope and checkpoints, and review commands and diffs before execution.

## Keep secrets out

Do not put API keys, passwords, access tokens, or customer information in SKILL.md or its examples. Check the visibility and access permissions of any file that will be committed to the repository.

# Summary

Agent Skills let you store task-specific procedures, decision criteria, and output formats in a project and load them into GitHub Copilot when relevant.

To create one, add .github/skills/<skill-name>/SKILL.md, set name and description, and write specific instructions in the body. Start with a small skill such as release-notes, then improve it by reviewing its results against real requests.

See Agent Skills in VS Code and the Agent Skills specification for details.

What Is GitHub Copilot?

ktdevx@gmail.com (Kaito Takemura) — Wed, 02 Sep 2026 00:00:00 +0900

GitHub Copilot is a service that uses AI to support software development. It improves developers’ productivity by suggesting code as they type and answering questions in natural language.

This article explains what GitHub Copilot is, what it can do, and what to keep in mind when using it.

# What Is GitHub Copilot?

GitHub Copilot is an AI coding assistant that generates code suggestions based on the context of the code and comments written by the developer.

It can do more than generate code automatically. You can also use it to explain code, investigate the cause of errors, create test code, and discuss implementation approaches. It is a support tool that helps developers work with suggestions, rather than a tool that makes every decision on their behalf.

# What Can GitHub Copilot Do?

## Code Completion

When you enter code or comments in an editor, GitHub Copilot suggests possible continuations.

This can reduce the effort required to write function templates and other routine code. You can review the suggestions before accepting them.

## Ask Questions in Chat

You can ask questions about code and errors through a chat interface.

For example, you can ask GitHub Copilot to:

Explain what selected code does
Suggest the cause of an error and ways to fix it
Convert code to another programming language
Create test code
Suggest ways to improve code

## Use It from the Command Line

GitHub Copilot can also be used from the command line through GitHub CLI. It can help you discuss shell commands and understand what commands do.

However, you should check the target files and options before executing a suggested command instead of running it without review.

## Support Pull Requests and Code Reviews

GitHub Copilot can create descriptions of changes and support code reviews. It can help organize an overview of changes and identify items that are easy to overlook.

## Support Development as an Agent

Depending on the available features and plan, GitHub Copilot can support tasks such as researching implementation approaches, creating plans, changing code, and creating Pull Requests.

Even in this case, developers should review the generated changes and run tests and other checks before incorporating them into a project.

# Where Can You Use GitHub Copilot?

GitHub Copilot is available in multiple development environments, including Visual Studio Code. Common places where it can be used include:

IDEs such as Visual Studio Code
The GitHub website
GitHub Mobile
The command line through GitHub CLI
Development environments such as Visual Studio, Xcode, and JetBrains IDEs

Supported environments and available features may change. Before getting started, check the official documentation to confirm that your environment is supported.

# Benefits of GitHub Copilot

GitHub Copilot can reduce the time required to enter routine code and research implementation approaches. It can also provide useful examples when you are working with a programming language or library that you are not familiar with.

Because you can ask it to explain code and suggest improvements, it can also help you begin understanding an existing codebase. However, its answers are not always correct. You should understand the code yourself instead of relying on it for every learning or design decision.

# Things to Keep in Mind

## Verify Generated Code

Code generated by GitHub Copilot may contain errors, inefficient processing, or vulnerabilities. Before using it, review the code and run tests and static analysis.

Security-sensitive code involving authentication, authorization, input validation, encryption, and database operations requires especially careful review.

## Do Not Enter Sensitive Information

Do not include API keys, passwords, personal information, or confidential company information in chat messages or prompts. When using GitHub Copilot in an organization, also check the company’s security policies and GitHub’s administrative settings.

## Check Licenses

Generated code may resemble existing code. If you use it in publicly distributed software, check the project’s license and the terms of any dependent libraries, and take any required action.

## Check Usage Limits

Available models, the number of completions and chat requests, and AI credits vary by plan and feature. Plan details and prices may change, so check the official pricing page for the latest information.

# Pricing Plans and Getting Started

GitHub Copilot offers a free plan and paid plans for individuals, as well as plans for organizations and enterprises. Available features and usage limits vary by plan.

For the latest pricing, available features, and supported environments, see the following official pages:

To get started, sign in to the official website with your GitHub account and choose a plan that fits your needs. Then install the required extensions or configure the tools for your IDE or GitHub CLI.

# Summary

GitHub Copilot is an AI service that supports software development through code completion, chat, the command line, and code reviews. It can make routine tasks more efficient and serve as a partner when considering implementation approaches.

However, generated code is not guaranteed to be correct. Do not enter sensitive information, check security and licensing requirements, and use GitHub Copilot alongside testing and code review.

GitHub Copilot on KTDEVX

Basic GitHub Copilot Usage in VS Code

# Prerequisites

# Install the GitHub Copilot extension

# Sign in with your GitHub account

# Use code completion

# Review multiple suggestions

# Ask questions in Copilot Chat

# Choose Ask, Plan, or Agent mode

## Ask mode

## Plan mode

## Agent mode

# Choose a model

# Choose thinking effort

# Understand credits

# Explain or modify selected code

# Use inline chat

# Review and apply suggestions

# Things to keep in mind

## Do not enter sensitive information

## Verify generated code

## Check licenses and dependencies

## Keep changes small

# Summary

How to Configure GitHub Copilot Context Files

# Prerequisites

# Types of context files

# Add repository-wide instructions

## Create the file

# Add path-specific instructions

# Use AGENTS.md

# Write useful instructions

# Check whether instructions are applied

# Troubleshoot missing instructions

# Things to keep in mind

## Keep instructions short and specific

## Verify generated results

## Do not include sensitive information

## Check feature support

# Summary

How to Create and Use Agent Skills in VS Code

# Prerequisites

# What are Agent Skills?

# Prepare the hands-on exercise

# Write the skill

# Check that VS Code recognizes the skill

# Run the skill

# Use additional files

# Agent Skill design guidelines

## Keep one purpose

## Define the procedure and completion criteria

## Limit permissions

## Keep secrets out

# Summary

What Is GitHub Copilot?

# What Is GitHub Copilot?

# What Can GitHub Copilot Do?

## Code Completion

## Ask Questions in Chat

## Use It from the Command Line

## Support Pull Requests and Code Reviews

## Support Development as an Agent

# Where Can You Use GitHub Copilot?

# Benefits of GitHub Copilot

# Things to Keep in Mind

## Verify Generated Code

## Do Not Enter Sensitive Information

## Check Licenses

## Check Usage Limits

# Pricing Plans and Getting Started

# Summary