Agent help

[groupthinking]

GOAL: Generate agent run Repo

• Start by mapping a repo tree , and mermaid diagram
• Next, visit https://github.com/orgs/github/repositories
• Build a check list
• agents? Tools? MCP? Pull push, request? Commit? Merge? Issues? Code ? Deps? Database? Actions? Role assignment?

Example & needs to be added: agentic workflow, critical component

gh aw add githubnext/agentics@da02ddd
M

Next: Example below 👇 while MCP directory found here : https://modelcontextprotocol.io/llms.txt and Skills found Here: Skills.sh both comprehensive. Their details are also below.

You have been tasked with updating the repo by Add the examples below, making them specific to this repo. (Obtain tree+Deps+readme) to make sure you are updating the below correctly for this repo specifically.

Next, you will visit Skills.Sh, pick at least 2 or more skills from Skills.sh to add into this repo that will bring added value, benefit for this specific repo.

Last, you will visit https://modelcontextprotocol.io/specification/2026-07-28 with the objective of understanding how the or if the repo your working from is using MCP or not. GitHub offers mcp by default but not every repo is utilizing it.

At the minimum you are to make certain the base capabilities are functional for negotiation to occur . Upon proving the baseline of mcp is functional for the repo, you can make the decision about adding additional. This is the final step before returning back to commit merge.

Host
The host process acts as the container and coordinator:

• Creates and manages multiple client instances
• Controls client connection permissions and lifecycle
• Enforces security policies and consent requirements
• Handles user authorization decisions
• Coordinates AI/LLM integration and sampling
• Manages context aggregation across clients
  ​

Clients
Each client is created by the host and communicates with exactly one server:

• Communicates with exactly one server
• Attaches protocol version and capabilities to every request
• Routes protocol messages bidirectionally
• Manages subscriptions and notifications
• Maintains security boundaries between servers
  A host application creates and manages multiple clients, with each client having a 1:1 relationship with a particular server.
  ​

Servers
Servers provide specialized context and capabilities:

• Expose resources, tools and prompts via MCP primitives
• Operate independently with focused responsibilities
• Request client input (sampling, elicitation, roots) via InputRequiredResult within a reply
• Must respect security constraints
• Can be local processes or remote services
  ​

Design Principles
MCP is built on several key design principles that inform its architecture and implementation:

1. Servers should be extremely easy to build
   • Host applications handle complex orchestration responsibilities
   • Servers focus on specific, well-defined capabilities
   • Simple interfaces minimize implementation overhead
   • Clear separation enables maintainable code
2. Servers should be highly composable
   • Each server provides focused functionality in isolation
   • Multiple servers can be combined seamlessly
   • Shared protocol enables interoperability
   • Modular design supports extensibility
3. Servers should not be able to read the whole conversation, nor “see into” other servers
   • Servers receive only necessary contextual information
   • Full conversation history stays with the host
   • Each server maintains isolation
   • Cross-server interactions are controlled by the host
   • Host process enforces security boundaries
4. Features can be added to servers and clients progressively
   • Core protocol provides minimal required functionality
   • Additional capabilities can be negotiated as needed
   • Servers and clients evolve independently
   • Protocol designed for future extensibility
   • Backwards compatibility is maintained
     ​

Capability Negotiation
The Model Context Protocol uses a capability-based negotiation system where clients and servers declare their supported features on each request. Clients include their capabilities in _meta.io.modelcontextprotocol/clientCapabilities on every request. Servers advertise their capabilities in response to server/discover, which clients may call before any other request for up-front capability discovery.

• Servers declare capabilities like tool support, resource subscriptions, and prompt templates
• Clients declare capabilities like sampling support and elicitation handling
• Both parties must respect declared capabilities throughout the interaction
• Additional capabilities can be negotiated through extensions to the protocol
  —
  Server
  Client
  Host
  Server
  Client
  Host
  opt
  [Discovery]
  alt
  [Server requires client input]
  loop
  [Client Requests]
  loop
  [Stream]
  opt
  [Subscriptions]
  server/discover
  supported versions + capabilities
  User- or model-initiated action
  Request (with _meta: version, clientCapabilities)
  InputRequiredResult (e.g. sampling/createMessage)
  Forward to AI
  AI response
  Original request (with input)
  Response
  Update UI or respond to model
  subscriptions/listen (toolsListChanged, resourceSubscriptions, …)
  notifications/subscriptions/acknowledged
  notifications/* (tagged with subscriptionId)
  ——
  Each capability unlocks specific protocol features on a per-request basis.
  For example:
• Implemented server features must be advertised in the server’s capabilities
• Receiving resource update notifications requires opening a subscriptions/listen stream with the desired resource URIs
• Tool invocation requires the server to declare tool capabilities
  This capability negotiation ensures clients and servers have a clear understanding of supported functionality while maintaining protocol extensibility.

Change Copilot's behavior, abilities, processes for particular tasks.

Note
Agent skills work with Copilot cloud agent, Copilot code review, the GitHub Copilot CLI, the GitHub Copilot app, and agent mode in Visual Studio Code.
Agent skills are folders of instructions, scripts, and resources that Copilot can load when relevant to improve its performance in specialized tasks. For more information, see About agent skills.

Creating and adding a skill
To create an agent skill, you write a SKILL.md file and, optionally, other resources, such as supplementary Markdown files, or scripts, which you reference in the SKILL.md instructions.

1. If you haven't already done so, create a skills directory in one of the following locations. This is where you will locate your skill, and any others you may want to create in the future.
For project skills, specific to a single repository, create a .github/skills, .claude/skills, or .agents/skillsdirectory in your repository.
For personal skills, shared across projects, create a ~/.copilot/skills or ~/.agents/skills directory in your local home directory.
2. Within the skills directory, create a subdirectory for your new skill. Each skill should have its own directory (for example, .github/skills/webapp-testing).
Skill subdirectory names should be lowercase and use hyphens for spaces.
3. In your skill subdirectory, create a SKILL.mdfile containing your skill's instructions.
[!IMPORTANT]
Skill files must be named SKILL.md.

SKILL.md files are Markdown files with YAML frontmatter. In their simplest form, they include:
   • YAML frontmatter
     • name (required): A unique identifier for the skill. This must be lowercase, using hyphens for spaces. Typically, this matches the name of the skill's directory.
     • description (required): A description of what the skill does, and when Copilot should use it.
     • license (optional): A description of the license that applies to this skill.
   • A Markdown body, with the instructions, examples and guidelines for Copilot to follow.
4. Optionally, add scripts, examples or other resources to your skill's directory.
For more information, see "Enabling a skill to run a script."
   Example SKILL.md file
   For a project skill, this file would be located in a .github/skills/github-actions-failure-debugging directory of your repository.
   For a personal skill, this file would be located in a ~/.copilot/skills/github-actions-failure-debugging directory.

---

name: github-actions-failure-debugging
description: Guide for debugging failing GitHub Actions workflows. Use this when asked to debug failing GitHub Actions workflows.

To debug failing GitHub Actions workflows in a pull request, follow this process, using tools provided from the GitHub MCP Server:

1. Use the list_workflow_runs tool to look up recent workflow runs for the pull request and their status
2. Use the summarize_job_log_failures tool to get an AI summary of the logs for failed jobs, to understand what went wrong without filling your context windows with thousands of lines of logs
3. If you still need more information, use the get_job_logs or get_workflow_run_logs tool to get the full, detailed failure logs
4. Try to reproduce the failure yourself in your own environment.
5. Fix the failing build. If you were able to reproduce the failure yourself, make sure it is fixed before committing your changes.
   Enabling a skill to run a script
   When a skill is invoked, Copilot automatically discovers all of the files in the skill's directory and makes them available alongside the skill's instructions. This means you can include scripts or other resources in the skill directory and reference them in your SKILL.md instructions.
   To create a skill that runs a script:
6. Add the script to your skill's directory. For example, a skill for converting SVG images to PNG might have the following structure.
.github/skills/image-convert/
7. ├── SKILL.md
8. └── convert-svg-to-png.sh
9. 

10. Optionally pre-approve the tools the skill needs. In your SKILL.md frontmatter, you can use the allowed-tools field to list the tools Copilot may use without asking for confirmation each time. If a tool is not listed in the allowed-tools field, Copilot will prompt you for permission before using it.
---
11. name: image-convert
12. description: Converts SVG images to PNG format. Use when asked to convert SVG files.
13. allowed-tools: shell
14. ---

[!WARNING]
Only pre-approve the shell or bash tools if you have reviewed this skill and any referenced scripts, and you fully trust their source. Pre-approving shell or bashremoves the confirmation step for running terminal commands and can allow attacker-controlled skills or prompt injections to execute arbitrary commands in your environment. When in doubt, omit shelland bash from allowed-tools so that Copilot must ask for your explicit confirmation before running terminal commands.

15. Write instructions that tell Copilot how to use the script. In the Markdown body of SKILL.md, describe when and how to run the script.
When asked to convert an SVG to PNG, run the convert-svg-to-png.sh script
16. from this skill's base directory, passing the input SVG file path as the
17. first argument.

    Adding a skill that someone else has created
    In addition to creating your own skills, you can also add skills that other people have created.

Tip
You can also use gh skill in GitHub CLI to search for, install, update, and publish agent skills. For more information, see Adding agent skills for GitHub Copilot.

1. Download a skill directory (that is, a directory containing a SKILL.md file and, optionally, other files and subdirectories).
For example, download a skill from the Awesome GitHub Copilot repository: https://awesome-copilot.github.com/skills/.
2. If you downloaded a .zip file, unzip this.
3. Move the skill directory to the required location:
   • For project skills, specific to a single repository: .github/skills, .claude/skills, or .agents/skills in your repository.
   • For personal skills, shared across projects: ~/.copilot/skills or ~/.agents/skills in your local home directory.
     Managing skills with GitHub CLI

Note
gh skill is in public preview and subject to change. To use it, update GitHub CLI to version 2.90.0 or later.
You can use the gh skill command in GitHub CLI to discover, install, update, and publish agent skills from GitHub repositories.
For the full list of gh skill subcommands, run gh skill --help or see the gh skill section of the GitHub CLI manual.
Installing skills
You can search for skills, preview them, and install them from GitHub repositories.

Warning
Skills are not verified by GitHub and may contain prompt injections, hidden instructions, or malicious scripts. Always inspect the content of a skill before installation using gh skill preview.

1. Search for skills by topic:
gh skill search TOPIC

2. Preview a skill to inspect its contents before installing. This renders the skill's SKILL.mdand file tree in your terminal without installing anything:
gh skill preview OWNER/REPOSITORY SKILL

3. Install a skill. You can run gh skill installwith no arguments for a fully interactive flow, or specify a repository to browse its skills interactively:
gh skill install OWNER/REPOSITORY

To install a specific skill directly:
gh skill install OWNER/REPOSITORY SKILL

For example, to install a skill from the github/awesome-copilot repository:
gh skill install github/awesome-copilot documentation-writer

You can install a specific version using @tag or @sha:
gh skill install github/awesome-copilot documentation-writer@v1.2.0

To lock a skill to a specific version (or commit SHA) so it is skipped during updates, use --pin:
gh skill install github/awesome-copilot documentation-writer --pin v1.2.0

[!NOTE]
The @Version syntax and --pin flag are mutually exclusive. Use one or the other, not both.

To install a skill for a specific agent host, use the --agent flag. To control the install scope, use --scope:
gh skill install github/awesome-copilot documentation-writer --agent claude-code --scope user

   Skills are automatically installed to the correct directory for your agent host. By default, skills are installed for Copilot at project scope.
   Updating skills
   When you install a skill with gh skill, provenance metadata is written into the skill's SKILL.mdfrontmatter, including the source repository, ref, and tree SHA. The gh skill update command uses this metadata to check for upstream changes.
   To check for updates interactively:
   gh skill update
   To update a specific skill:
   gh skill update SKILL
   To update all installed skills without prompting:
   gh skill update --all
   Pinned skills are skipped during updates. To update a pinned skill, reinstall it with a new --pin value.
   Publishing skills
   If you maintain a skills repository, you can validate and publish your skills using GitHub CLI.
   To validate your skills against the Agent Skills specification and check remote settings like tag protection, secret scanning, and code scanning, without publishing, use --dry-run:
   gh skill publish --dry-run
   To auto-fix metadata issues in your skill files, use --fix. This does not publish your skills:
   gh skill publish --fix
   To validate and publish your skills:
   gh skill publish
   How Copilot uses agent skills
   When performing tasks, Copilot will decide when to use your skills based on your prompt and the skill's description.
   When Copilot chooses to use a skill, the SKILL.mdfile will be injected in the agent's context, giving the agent access to your instructions. It can then follow those instructions and use any scripts or examples you may have included in the skill's directory.
   For Copilot code review on GitHub, keep the following in mind:

• If you want to ensure that Copilot code review will read and use a skill, use a review-focused skill directory name such as code-review.
• Existing skills within the .github/skillsdirectory can also be used by Copilot code review automatically when they are relevant to the review.
  Skills versus custom instructions
  You can use both skills and custom instructions to teach Copilot how to work in your repository and how to perform specific tasks.
  We recommend using custom instructions for simple instructions relevant to almost every task (for example information about your repository's coding standards), and skills for more detailed instructions that Copilot should only access when relevant.
  To learn more about repository custom instructions, see Adding repository custom instructions for GitHub Copilot.

Using GitHub Copilot code review

Learn how to request a code review from GitHub Copilot.

Introduction

GitHub Copilot can review your code and provide feedback. Where possible, Copilot's feedback includes suggested changes which you can apply with a couple of clicks.

For a full introduction to GitHub Copilot code review, see About GitHub Copilot code review.

Copilot code review uses GitHub Actions to run agentic capabilities. For more information, see Agentic capabilities for Copilot code review.

Copilot code review is also available for organization members without a Copilot license, when enabled by an enterprise administrator or organization owner. See Copilot code review for organization members without a Copilot license.

Using Copilot code review

These instructions explain how to use Copilot code review in the GitHub website. To see instructions for other popular coding environments, click the appropriate tab at the top of the page.

1. On GitHub.com, create a pull request or navigate to an existing pull request.

2. Under "Reviewers" in the right sidebar, next to Copilot, click Request.

   

3. Wait for Copilot to review your pull request. This usually takes less than 30 seconds.

4. Scroll down and read through Copilot's comments.

   

   Copilot labels each comment with a severity level of "High," "Medium," or "Low" to help you prioritize the issues it finds based on their importance.

   By default, Copilot leaves a "Comment" review, not an "Approve" review or a "Request changes" review. This means that, by default, Copilot's reviews do not count toward required approvals for the pull request. However, if configured to do so, Copilot can leave "Approve" reviews. For more information, see Pull request approvals from Copilot.

5. Where possible, Copilot's feedback includes suggested changes which you can apply with a couple of clicks.

   If you're happy with the changes, you can accept a single suggestion from Copilot and commit it, or accept a group of suggestions together in a single commit. For more information, see Incorporating feedback in your pull request.

   You can also invoke Copilot cloud agent to implement suggested changes. To do this, you must:

   • Enable GitHub Copilot code review and Copilot cloud agent.
   • On review comments from GitHub Copilot code review, click Fix with Copilot. This creates a draft comment on the pull request, where you can instruct Copilot to address specific feedback. You can then select whether Copilot will create a new pull request against your branch or a commit to the same pull request with the suggestions applied.

6. Copilot's review comments behave like review comments from humans. You can add reactions to them, comment on them, resolve them and hide them.

   Any comments you add to Copilot's review comments will be visible to humans, but they won't be visible to Copilot, and Copilot won't reply.

You can also request a review from Copilot through the GitHub REST API by requesting copilot-pull-request-reviewer[bot] as a reviewer. For more information, see REST API endpoints for review requests.

Enabling automatic reviews

By default, you manually request a review from Copilot on each pull request, in the same way you would request a review from a human. However, you can set up Copilot to automatically review all pull requests. See Configuring code review by GitHub Copilot.

Requesting a re-review from Copilot

When you push changes to a pull request that Copilot has reviewed, it won't automatically re-review your changes unless you've configured it to review new pushes after enabling automatic reviews.

To manually request a re-review from Copilot, click the button next to Copilot's name in the Reviewers menu. For more information, see Requesting a pull request review.

To automatically request re-reviews from Copilot on every push, enable automatic code review for the repository and select Review new pushes in the ruleset settings. For more information, see Configuring code review by GitHub Copilot.

[!NOTE] When re-reviewing a pull request, Copilot may repeat the same comments again, even if they have been dismissed with the "Resolve conversation" button or downvoted with the thumbs down (:-1:) button.

Choosing a review effort level

With review effort levels, you can choose the level of thoroughness of Copilot's review that matches the criticality of your code.

• Lite: Cost-efficient review that provides targeted feedback on glaring issues such as bugs, security vulnerabilities, and style inconsistencies.
• Balanced: Deeper analysis of complex logic, security-sensitive code, and cross-service changes, using a higher-reasoning model.

You can select the review effort level in the pull request before you request a review from Copilot, under the Reviewers section where Copilot appears as a reviewer. Organization owners and repository administrators can also set a default effort level for automatic reviews.

For more information, see About GitHub Copilot code review.

Pull request approvals from Copilot

[!NOTE]
Copilot approvals are in public preview and subject to change.

Every Copilot code review includes an approval assessment in the overview comment, indicating whether Copilot considers the pull request ready to approve. On its own, this assessment does not count toward merge requirements.

When approvals are enabled, Copilot can submit an approving review that satisfies your repository's required-approval rule the same way a teammate's approval would. If new commits are pushed after Copilot approves, the approval is dismissed, and you can re-request a review. For more details on required reviews, see Approving a pull request with required reviews.

Approvals are off by default and can be configured at the enterprise, organization, and repository levels. Repository administrators can also use file paths to control which Copilot approvals count toward merge requirements. For configuration steps, see Configuring code review by GitHub Copilot.

Customizing Copilot's reviews with custom instructions

You can customize Copilot code review by adding custom instructions to your repository. Repository custom instructions can either be repository wide or path specific.

Use .github/copilot-instructions.md for repository-wide review guidance that should apply across the entire codebase. This is a good place to describe organization-wide expectations, such as coding standards, review criteria, or general practices that Copilot should consider in every review.

Use an AGENTS.md file in the root of your repository to provide additional repository context that helps Copilot better understand how your project works. For example, you can explain which patterns are intentional, which parts of the codebase need closer scrutiny, and what your team considers good architecture, testing, and implementation practices. This helps make reviews more relevant and aligned with the way your team builds software.

Use .github/instructions/**/*.instructions.md files for path-specific instructions that only apply when reviewing matching files. This is useful when different parts of the repository follow different conventions, require specialized checks, or need review guidance tailored to a particular language, framework, or subsystem.

Copilot code review also reads custom instructions from CLAUDE.md, GEMINI.md, and REVIEW.md files in your repository, if they exist.

For more information, see Adding repository custom instructions for GitHub Copilot.

[!NOTE]
When reviewing a pull request, Copilot reads repository custom instructions, agent instructions, and agent skills from the head branch (the branch with your changes), not the base branch. For example, when merging my-feature-branch into main, Copilot uses the instructions and skills in my-feature-branch, so you can test changes to them in the same pull request without merging them first.

Example

This example of a .github/copilot-instructions.md file contains three instructions that will be applied to all Copilot code reviews in the repository.

When performing a code review, respond in Spanish.

When performing a code review, apply the checks in the `/security/security-checklist.md` file.

When performing a code review, focus on readability and avoid nested ternary operators.

MCP servers and agent skills

Copilot code review can use agent skills and MCP servers configured in the repository, when they are relevant to the code being reviewed.

To make these available for Copilot code review on GitHub, configure:

• Agent skills in your repository (in .github/skills). If you want a skill to target review tasks, use a review-focused skill directory name such as code-review. For setup details, see Adding agent skills for GitHub Copilot.
• MCP servers in repository Copilot settings. The GitHub MCP server and Playwright MCP server are enabled by default. For setup details, see Configure MCP servers for your repository.

Copilot code review is more likely to use this context when:

• Agent skills directories have review-focused names and descriptions, such as code-review, that indicate they are intended for pull request review.
• Your agent skills or custom instructions explicitly tell Copilot code review to use specific MCP context.
• Pull request descriptions reference items available through configured MCP servers, such as issue keys or incident IDs.

To verify which MCP context Copilot code review used for a specific review, check if there are attributions at the bottom of each review comment. These attributions reference the specific agent skill or MCP server that Copilot code review used to generate that comment. You can also open the linked review session from the pull request timeline, then check the session logs to see which MCP servers and tools were called.

In repository settings, Allow Copilot to use MCP tools when reviewing pull requests is enabled by default. Disable this setting if you want MCP servers available only for Copilot cloud agent, and not for Copilot code review. For step-by-step instructions, see Configure MCP servers for your repository.

Customizing Copilot code review's environment

Copilot code review runs in an ephemeral development environment, similar to Copilot cloud agent. You can customize this environment using a GitHub Actions workflow file, in the same way you would for Copilot cloud agent, for example, to preinstall tools or dependencies, or to switch to a different operating system. For more information on how to structure this file, see Configure the development environment.

You can use either of the following files to configure Copilot code review's environment:

• .github/workflows/copilot-setup-steps.yml: If you have already configured this file for Copilot cloud agent, Copilot code review will use the same configuration by default.
• .github/workflows/copilot-code-review.yml: We recommend creating this file if you want to configure Copilot code review's environment independently of Copilot cloud agent. If this file is present in your repository, it is used for Copilot code review instead of copilot-setup-steps.yml.

You can also configure firewall rules to control the domains and URLs that Copilot code review can access, at both the organization and repository level. These settings are configured separately from Copilot cloud agent's firewall settings, in their own section of the same "Internet access" tab. See Customizing or disabling the firewall for GitHub Copilot.

Providing feedback on Copilot's reviews

You can provide feedback on Copilot's comments directly within each comment. We use this information to improve the product and the quality of Copilot's suggestions.

To provide feedback on a review comment from Copilot, click the thumbs up (:+1:) or thumbs down (:-1:) button.

Reviewing a selection of code

You can request an initial review of a highlighted selection of code in Visual Studio Code.

1. In Visual Studio Code, select the code you want to review.
2. Right-click the selected code and choose Generate Code > Review.
3. VS Code creates review comments in the Comments panel and also shows them inline in the editor.

Reviewing all uncommitted changes

If you have uncommitted changes, you can request a review in Visual Studio Code.

1. In VS Code, click the Source Control button in the Activity Bar.

2. At the top of the Source Control view, hover over CHANGES, then click the Copilot Code Review - Uncommitted Changes button.

   

3. Wait for Copilot to review your changes. This usually takes less than 30 seconds.

4. If Copilot has any comments, they will be shown inline in your file(s), and in the Problems tab.

Working with suggested changes provided by Copilot

Where possible, Copilot's feedback includes suggested changes which you can apply with a single click.

If you're happy with the change, you can accept a suggestion from Copilot by clicking the Apply and Go To Next button. Any changes you apply will not be automatically committed.

If you don't want to apply Copilot's suggested change, click the Discard and Go to Next button.

Providing feedback on Copilot's reviews

You can provide feedback on Copilot's comments directly within each comment. We use this information to improve the product and the quality of Copilot's suggestions.

To provide feedback, hover over the comment and click the thumbs up or thumbs down button.

Customizing Copilot's reviews with custom instructions

You can customize Copilot code review by adding custom instructions to your repository. Repository custom instructions can either be repository wide or path specific.

Use .github/copilot-instructions.md for repository-wide review guidance that should apply across the entire codebase. This is a good place to describe organization-wide expectations, such as coding standards, review criteria, or general practices that Copilot should consider in every review.

Use an AGENTS.md file in the root of your repository to provide additional repository context that helps Copilot better understand how your project works. For example, you can explain which patterns are intentional, which parts of the codebase need closer scrutiny, and what your team considers good architecture, testing, and implementation practices. This helps make reviews more relevant and aligned with the way your team builds software.

Use .github/instructions/**/*.instructions.md files for path-specific instructions that only apply when reviewing matching files. This is useful when different parts of the repository follow different conventions, require specialized checks, or need review guidance tailored to a particular language, framework, or subsystem.

Copilot code review also reads custom instructions from CLAUDE.md, GEMINI.md, and REVIEW.md files in your repository, if they exist.

For more information, see Adding repository custom instructions for GitHub Copilot.

[!NOTE]
When reviewing a pull request, Copilot reads repository custom instructions, agent instructions, and agent skills from the head branch (the branch with your changes), not the base branch. For example, when merging my-feature-branch into main, Copilot uses the instructions and skills in my-feature-branch, so you can test changes to them in the same pull request without merging them first.

Example

This example of a .github/copilot-instructions.md file contains three instructions that will be applied to all Copilot code reviews in the repository.

When performing a code review, respond in Spanish.

When performing a code review, apply the checks in the `/security/security-checklist.md` file.

When performing a code review, focus on readability and avoid nested ternary operators.

Prerequisite

To use Copilot code review, you must use Visual Studio version 17.14 or later. See the Visual Studio downloads page.

Using Copilot code review

These instructions explain how to use Copilot code review in Visual Studio. To see instructions for other popular coding environments, click the appropriate tab at the top of the page.

1. In the Git Changes window, click Review changes with Copilot.
   This button appears as a comment icon with a sparkle.

2. Copilot will begin reviewing your changes. After a few moments, a link showing the number of code review comments appears in the Git Changes window.

3. Click the link to view and navigate the comments. If no issues are found, you'll see the message:
   Copilot did not comment on any files.

4. Copilot displays comments in your code with a summary of each potential issue. You can:

   • Review and make changes based on the suggestions.
   • Dismiss a comment using the downward arrow in the top-right corner of the comment box.

5. To remove all review comments, click <svg version="1.1" width="16" height="16" viewBox="0 0 16 16" class="octicon octicon-x" aria-label="The X icon" next to the code review link in the Git Changes window.

For more information on enabling and configuring Copilot code review in Visual Studio, see Review local changes with Copilot Chat

Using Copilot code review - Mobile

These instructions explain how to use Copilot code review in GitHub Mobile. To see instructions for other popular coding environments, click the appropriate tab at the top of the page.

1. In GitHub Mobile, open a pull request.
2. Scroll down to the Reviews section and expand it.
3. Click Request Reviews.
4. Add Copilot as a reviewer, then click Done.

Copilot will review the changes and provide feedback.

Prerequisite

To use Copilot code review in Xcode, you must use version 0.41.0 or later of the GitHub Copilot Chat extension. Download the latest release from the github/CopilotForXcode repository.

Using Copilot code review - Xcode

These instructions explain how to use Copilot code review in Xcode. To see instructions for other popular coding environments, click the appropriate tab at the top of the page.

1. In Xcode, make some changes to one or more files.

2. Open the Copilot chat window by clicking Editor in the menu bar, clicking GitHub Copilot then Open Chat.

3. Near the bottom right of the prompt box in the Copilot chat window, click the Code Review button (a speech bubble icon).

   

4. Click either Review Staged Changes or Review Unstaged Changes.

5. A list of files containing changes is displayed in the chat window. Click the check boxes to deselect any files you don't want Copilot to review.

6. Click Continue to start the review process.

7. If Copilot finds things to comment on, it displays a Reviewed Changes list in the chat window, listing the files it has commented on. Click a file in this list to see the comments.

   Each comment is shown in a popup, overlaid over the editor.

   

8. If there is more than one comment in the file, use the up and down arrows, at the top right of the popup, to navigate between comments.

9. Copilot may suggest replacement code. You can apply the suggested change by clicking Accept or reject it by clicking Dismiss.

10. Click another file in the Reviewed Changes list in the chat window, to see the review comments for another file.

Prerequisites

• Access to Copilot. See What is GitHub Copilot?.

• Compatible JetBrains IDE. To use GitHub Copilot in JetBrains, you must have a compatible JetBrains IDE installed. GitHub Copilot is compatible with the following IDEs:

  • IntelliJ IDEA (Ultimate, Community, Educational)
  • Android Studio
  • CLion
  • Code With Me Guest
  • DataGrip
  • DataSpell
  • GoLand
  • JetBrains Client
  • MPS
  • PhpStorm
  • PyCharm (Professional, Community, Educational)
  • Rider
  • RubyMine
  • RustRover
  • WebStorm

  See the JetBrains IDEs tool finder to download.

• Latest version of the GitHub Copilot extension. See the GitHub Copilot plugin in the JetBrains Marketplace. For installation instructions, see Installing the GitHub Copilot extension in your environment.

• Sign in to GitHub in your JetBrains IDE. For authentication instructions, see Installing the GitHub Copilot extension in your environment.

Using Copilot code review - JetBrains

These instructions explain how to use Copilot code review in JetBrains IDEs. To see instructions for other popular coding environments, click the appropriate tab at the top of the page.

1. In a JetBrains IDE, make some changes to one or more files.

2. Open the "Commit" tool window on the left-hand side.

3. Above the commit message input field, click Copilot: Review Code Changes. This button appears as a magnifying glass icon with a sparkle.

4. Copilot will begin reviewing your changes.

5. Copilot displays comments in your code with a summary of each potential issue. You can:

   • Review and make changes based on the suggestions.
   • Dismiss a comment by clicking Discard.

6. If there is more than one comment, use the up and down arrows, at the top right of the popup, to navigate between comments.

Prerequisites

• Access to Copilot. See What is GitHub Copilot?.
• GitHub CLI. You must have the GitHub CLI installed and authenticated. See GitHub CLI quickstart.

Using Copilot code review - CLI

These instructions explain how to use Copilot code review with the GitHub CLI. To see instructions for other popular coding environments, click the appropriate tab at the top of the page.

Requesting a review when creating a pull request

You can request a review from Copilot when creating a new pull request using gh pr create:

gh pr create --reviewer @copilot

You can also select Copilot interactively from the searchable reviewer prompt during gh pr create.

? Reviewers  [Use arrows to move, space to select, <right> to all, <left> to none, type to filter]
  [ ]  Search (7472 more)
  [x]  monalisa (Mona Lisa)
> [x]  Copilot (AI)

Requesting a review on an existing pull request

To request a review from Copilot on an existing pull request, use gh pr edit. If you are not on the pull request's branch, specify the pull request number:

gh pr edit PR-NUMBER --add-reviewer @copilot

Replace PR-NUMBER with the number of the pull request you want reviewed. If you have the pull request's branch checked out, you can omit the number.

—

MCP Documentation Index
Use this file to discover all available pages before exploring further.

Specification

Model Context Protocol (MCP) is an open protocol that enables seamless integration between LLM applications and external data sources and tools. Whether you're building an AI-powered IDE, enhancing a chat interface, or creating custom AI workflows, MCP provides a standardized way to connect LLMs with the context they need.

This specification defines the authoritative protocol requirements, based on the
TypeScript schema in
schema.ts.

For implementation guides and examples, visit
modelcontextprotocol.io.

The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD
NOT", "RECOMMENDED", "NOT RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be
interpreted as described in BCP 14
[RFC2119]
[RFC8174] when, and only when, they
appear in all capitals, as shown here.

Overview

MCP provides a standardized way for applications to:

• Share contextual information with language models
• Expose tools and capabilities to AI systems
• Build composable integrations and workflows

The protocol uses JSON-RPC 2.0 messages to establish
communication between:

• Hosts: LLM applications that initiate connections
• Clients: Connectors within the host application
• Servers: Services that provide context and capabilities

MCP takes some inspiration from the
Language Server Protocol, which standardizes how to add support for programming languages across a whole ecosystem of development tools. In a similar way, MCP standardizes how to integrate additional context and tools into the ecosystem of AI applications.

Key Details

Base Protocol

• JSON-RPC message format
• Stateless, self-contained requests
• Per-request capability negotiation

Features

Servers offer any of the following features to clients:

• Resources: Context and data, for the user or the AI model to use
• Prompts: Templated messages and workflows for users
• Tools: Functions for the AI model to execute

Clients may offer the following features to servers:

• Elicitation: Server-initiated requests for additional information from users

Additional Utilities

• Configuration
• Progress tracking
• Cancellation
• Error reporting

Extensions

Beyond the core protocol, MCP defines optional extensions
that add modular, specialized, or experimental functionality. Extensions
are always opt-in and require explicit support from both client and server, negotiated
during initialization. Notable extensions include:

• Tasks: Asynchronous execution of long-running
  operations, with polling, mid-flight input, and durable handles
• Skills over MCP: Rich, structured
  instructions for agent workflows, discovered and consumed through MCP
• MCP Apps: Interactive UI elements (charts, forms,
  video players) rendered inline within conversations

Security and Trust & Safety

The Model Context Protocol enables powerful capabilities through arbitrary data access
and code execution paths. With this power comes important security and trust
considerations that all implementors must carefully address.

Key Principles

1. User Consent and Control

   • Users must explicitly consent to and understand all data access and operations
   • Users must retain control over what data is shared and what actions are taken
   • Implementors should provide clear UIs for reviewing and authorizing activities

2. Data Privacy

   • Hosts must obtain explicit user consent before exposing user data to servers
   • Hosts must not transmit resource data elsewhere without user consent
   • User data should be protected with appropriate access controls

3. Tool Safety

   • Tools represent arbitrary code execution and must be treated with appropriate
     caution.
     • In particular, descriptions of tool behavior such as annotations should be
       considered untrusted, unless obtained from a trusted server.
   • Hosts must obtain explicit user consent before invoking any tool
   • Users should understand what each tool does before authorizing its use

Implementation Guidelines

[linear-code]

GRV-495

[github-actions]

👋 Thanks for opening this issue! It has been automatically labeled for triage.