GitHub Copilot

https://docs.github.com/en/copilot
Admin
GitHub Copilot is an AI pair programmer that provides real-time code suggestions, chat capabilities,...
Tokens:1,437,179
Snippets:9,161
Trust Score:10
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### Prompt to start lsp-setup skill

Source: https://docs.github.com/en/copilot/how-tos/copilot-cli/set-up-copilot-cli/add-lsp-servers

Enter this prompt in Copilot CLI to start the lsp-setup skill, which automates installation and configuration of popular language servers. After completing the setup, use /lsp reload to load the new server.

```copilot
setup lsp
```

--------------------------------

### Install a skill from github/awesome-copilot

Source: https://docs.github.com/en/copilot/how-tos/copilot-on-github/customize-copilot/customize-cloud-agent/add-skills

Example command to install a skill from the github/awesome-copilot repository.

```shell
gh skill install github/awesome-copilot documentation-writer
```

--------------------------------

### Install a plugin from a marketplace

Source: https://docs.github.com/en/copilot/how-tos/copilot-cli/customize-copilot/plugins-finding-installing

Installs a plugin from a registered marketplace. The first command uses a placeholder; the second shows a concrete example; the third is the interactive-session equivalent.

```shell
copilot plugin install PLUGIN-NAME@MARKETPLACE-NAME
```

```shell
copilot plugin install database-data-management@awesome-copilot
```

```copilot
/plugin install PLUGIN-NAME@MARKETPLACE-NAME
```

--------------------------------

### Quick start with Microsoft Foundry using CopilotClient

Source: https://docs.github.com/en/copilot/how-tos/copilot-sdk/auth/byok

Shows the minimal Java setup for using the GitHub Copilot SDK with Microsoft Foundry. Requires the FOUNDRY_API_KEY environment variable and a deployment name for the model. The example sets the wire API to "responses" and notes that "completions" is used for older models.

```java
import com.github.copilot.CopilotClient;
import com.github.copilot.rpc.*;

var client = new CopilotClient();
client.start().get();

var session = client.createSession(new SessionConfig()
    .setModel("gpt-5.2-codex")  // Your deployment name
    .setOnPermissionRequest(PermissionHandler.APPROVE_ALL)
    .setProvider(new ProviderConfig()
        .setType("openai")
        .setBaseUrl("https://<resource-name>.openai.azure.com/openai/v1/")
        .setWireApi("responses")  // Use "completions" for older models
        .setApiKey(System.getenv("FOUNDRY_API_KEY")))
).get();

var response = session.sendAndWait(new MessageOptions()
    .setPrompt("What is 2+2?")).get();
System.out.println(response.getData().content());

client.stop().get();
```

--------------------------------

### Give examples: Go date-finding function prompt

Source: https://docs.github.com/en/copilot/concepts/prompting/prompt-engineering

Provide example input data and expected output to guide Copilot. This prompt asks for a Go function that extracts dates from a string, listing accepted formats and a concrete example.

```copilot
Write a Go function that finds all dates in a string and returns them in an array. Dates can be formatted like:

* 05/02/24
* 05/02/2024
* 5/2/24
* 5/2/2024
* 05-02-24
* 05-02-2024
* 5-2-24
* 5-2-2024

Example:

findDates("I have a dentist appointment on 11/14/2023 and book club on 12-1-23")

Returns: ["11/14/2023", "12-1-23"]
```

--------------------------------

### Example custom instructions file

Source: https://docs.github.com/en/copilot/concepts/prompting/response-customization?tool=jetbrains

Example custom instructions file that provides an overview of the project, lists libraries and frameworks, coding standards, and UI guidelines. Use as a starting point for writing effective custom instructions for Copilot.

```markdown
# Project Overview

This project is a web application that allows users to manage their tasks and to-do lists. It is built using React and Node.js, and uses MongoDB for data storage.

## Libraries and Frameworks

- React and Tailwind CSS for the frontend.
- Node.js and Express for the backend.
- MongoDB for data storage.

## Coding Standards

- Use semicolons at the end of each statement.
- Use single quotes for strings.
- Use function based components in React.
- Use arrow functions for callbacks.

## UI guidelines

- A toggle is provided to switch between light and dark mode.
- Application should have a modern and clean design.
```

--------------------------------

### Example copilot-instructions.md file

Source: https://docs.github.com/en/copilot/tutorials/cloud-agent/get-the-best-results

An example of an effective copilot-instructions.md file that guides Copilot on code standards, development flow, repository structure, and key guidelines for a Go-based repository with a Ruby client.

```markdown
This is a Go based repository with a Ruby client for certain API endpoints. It is primarily responsible for ingesting metered usage for GitHub and recording that usage. Please follow these guidelines when contributing:

## Code Standards

### Required Before Each Commit
- Run `make fmt` before committing any changes to ensure proper code formatting
- This will run gofmt on all Go files to maintain consistent style

### Development Flow
- Build: `make build`
- Test: `make test`
- Full CI check: `make ci` (includes build, fmt, lint, test)

## Repository Structure
- `cmd/`: Main service entry points and executables
- `internal/`: Logic related to interactions with other GitHub services
- `lib/`: Core Go packages for billing logic
- `admin/`: Admin interface components
- `config/`: Configuration files and templates
- `docs/`: Documentation
- `proto/`: Protocol buffer definitions. Run `make proto` after making updates here.
- `ruby/`: Ruby implementation components. Updates to this folder should include incrementing this version file using semantic versioning: `ruby/lib/billing-platform/version.rb`
- `testing/`: Test helpers and fixtures

## Key Guidelines
1. Follow Go best practices and idiomatic patterns
2. Maintain existing code structure and organization
3. Use dependency injection patterns where appropriate
4. Write unit tests for new functionality. Use table-driven unit tests when possible.
5. Document public APIs and complex logic. Suggest changes to the `docs/` folder when appropriate
```

--------------------------------

### Install Node dependencies in copilot-setup-steps.yml

Source: https://docs.github.com/en/copilot/tutorials/cloud-agent/give-access-to-resources

Workflow file that defines the environment setup steps Copilot runs before starting. It checks out the code, sets up Node.js 20 with npm caching, and installs dependencies using npm ci. The repository's GITHUB_TOKEN must be granted access to private organization-scoped packages for the install to succeed.

```yaml
# ...

jobs:
  copilot-setup-steps:
    # ...

    # You can define any steps you want, and they will run before the agent starts.
    # If you do not check out your code, Copilot will do this for you.
    steps:
      - name: Checkout code
        uses: actions/checkout@v6

      - name: Set up Node.js
        uses: actions/setup-node@v7
        with:
          node-version: "20"
          cache: "npm"

      - name: Install JavaScript dependencies
        run: npm ci

```

--------------------------------

### Install aspectlib

Source: https://docs.github.com/en/copilot/tutorials/copilot-cookbook/refactor-code/handle-cross-cutting

Install the aspectlib library, which is used in the example response to implement AOP for logging.

```bash
pip install aspectlib
```

--------------------------------

### sessionStart hook example

Source: https://docs.github.com/en/copilot/how-tos/copilot-cli/customize-copilot/use-hooks

Example of a sessionStart hook that logs the session start date to a file. Includes both bash and powershell commands, with a working directory and timeout.

```json
"sessionStart": [
  {
    "type": "command",
    "bash": "echo \"Session started: $(date)\" >> logs/session.log",
    "powershell": "Add-Content -Path logs/session.log -Value \"Session started: $(Get-Date)\"",
    "cwd": ".",
    "timeoutSec": 10
  }
],
```

--------------------------------

### Install Copilot SDK for Rust

Source: https://docs.github.com/en/copilot/get-started/sdk-quickstart

Creates a new binary crate and installs the Copilot SDK along with direct dependencies (tokio, serde, schemars) used by the examples.

```bash
cargo new copilot-demo && cd copilot-demo
```

```bash
cargo add github-copilot-sdk --features derive
# Used by #[tokio::main] and tokio::spawn
cargo add tokio --features rt-multi-thread,macros
# Used by custom-tool parameter derives later in this guide
cargo add serde --features derive
cargo add schemars
```

--------------------------------

### Example of effective custom instructions file

Source: https://docs.github.com/en/copilot/concepts/prompting/response-customization?tool=jetbrains

A sample instructions file that includes project overview, libraries and frameworks, coding standards, and UI guidelines. This is presented as a good starting point for writing custom instructions.

```markdown
# Project Overview

This project is a web application that allows users to manage their tasks and to-do lists. It is built using React and Node.js, and uses MongoDB for data storage.

## Libraries and Frameworks

- React and Tailwind CSS for the frontend.
- Node.js and Express for the backend.
- MongoDB for data storage.

## Coding Standards

- Use semicolons at the end of each statement.
- Use single quotes for strings.
- Use function based components in React.
- Use arrow functions for callbacks.

## UI guidelines

- A toggle is provided to switch between light and dark mode.
- Application should have a modern and clean design.

```

--------------------------------

### Configure Copilot SDK client with installation token (TypeScript, Python, Go, Rust, .NET, Java)

Source: https://docs.github.com/en/copilot/how-tos/copilot-sdk/auth/server-to-server-tokens

Configure the Copilot SDK client to use a minted installation token for server-to-server authentication. Each example reads INSTALLATION_TOKEN from the environment, passes it to the child runtime via COPILOT_GITHUB_TOKEN, and disables fallback to stored user credentials with useLoggedInUser/use_logged_in_user set to false. For in-process FFI, set COPILOT_GITHUB_TOKEN in the host environment before loading the runtime; per-client environment options are not supported. For an existing runtime URI, set it on that runtime process.

```typescript
import { CopilotClient, RuntimeConnection } from "@github/copilot-sdk";

const token = process.env.INSTALLATION_TOKEN;
if (!token) throw new Error("INSTALLATION_TOKEN is required");

const client = new CopilotClient({
    connection: RuntimeConnection.forStdio(),
    env: {
        ...process.env,
        COPILOT_GITHUB_TOKEN: token,
    },
    useLoggedInUser: false,
});
```

```python
import os

from copilot import CopilotClient, RuntimeConnection

client = CopilotClient(
    connection=RuntimeConnection.for_stdio(),
    env={**os.environ, "COPILOT_GITHUB_TOKEN": os.environ["INSTALLATION_TOKEN"]},
    use_logged_in_user=False,
)
```

```golang
package main

import (
	"log"
	"os"

	copilot "github.com/github/copilot-sdk/go"
)

func main() {
	token, ok := os.LookupEnv("INSTALLATION_TOKEN")
	if !ok {
		log.Fatal("INSTALLATION_TOKEN is required")
	}
	client := copilot.NewClient(&copilot.ClientOptions{
		Connection:      copilot.StdioConnection{},
		Env:             append(os.Environ(), "COPILOT_GITHUB_TOKEN="+token),
		UseLoggedInUser: copilot.Bool(false),
	})
	_ = client
}
```

```rust
use github_copilot_sdk::{ClientOptions, Transport};

fn main() {
    let token = std::env::var("INSTALLATION_TOKEN").expect("INSTALLATION_TOKEN is required");
    let options = ClientOptions::new()
        .with_transport(Transport::Stdio)
        .with_env([("COPILOT_GITHUB_TOKEN", token)])
        .with_use_logged_in_user(false);
    drop(options);
}
```

```csharp
using System.Collections;
using GitHub.Copilot;

var token = Environment.GetEnvironmentVariable("INSTALLATION_TOKEN")
    ?? throw new InvalidOperationException("INSTALLATION_TOKEN is required");
var environment = Environment.GetEnvironmentVariables()
    .Cast<DictionaryEntry>()
    .ToDictionary(entry => (string)entry.Key, entry => entry.Value?.ToString() ?? "");
environment["COPILOT_GITHUB_TOKEN"] = token;

await using var client = new CopilotClient(new CopilotClientOptions
{
    Connection = RuntimeConnection.ForStdio(),
    Environment = environment,
    UseLoggedInUser = false,
});
```

```java
import com.github.copilot.CopilotClient;
import com.github.copilot.rpc.CopilotClientOptions;
import java.util.HashMap;
import java.util.Objects;

var environment = new HashMap<>(System.getenv());
var token = Objects.requireNonNull(
    System.getenv("INSTALLATION_TOKEN"), "INSTALLATION_TOKEN is required");
environment.put("COPILOT_GITHUB_TOKEN", token);

try (var client = new CopilotClient(new CopilotClientOptions()
        .setEnvironment(environment)
        .setUseLoggedInUser(false))) {
    // Use the client.
}
```

--------------------------------

### Foundry Local CLI installation and usage commands

Source: https://docs.github.com/en/copilot/how-tos/copilot-sdk/auth/byok

Install the Foundry Local CLI on Windows via winget, list available models, run a model (which starts the local server automatically), and check the service port with `foundry service status`. For macOS/Linux, see the Foundry Local website for installation instructions.

```bash
# Windows: Install Foundry Local CLI (requires winget)
winget install Microsoft.FoundryLocal

# macOS / Linux: see https://foundrylocal.ai for installation instructions
# List available models
foundry model list

# Run a model (starts the local server automatically)
foundry model run phi-4-mini

# Check the port the service is running on
foundry service status
```

--------------------------------

### Add steps to copilot-setup-steps job

Source: https://docs.github.com/en/copilot/how-tos/copilot-on-github/customize-copilot/customize-cloud-agent/customize-the-agent-environment

Defines a `copilot-setup-steps` job in a workflow file to deterministically install tools or dependencies before Copilot starts work. The steps run before the agent starts; if you do not check out your code, Copilot will do it for you.

```yaml
# ...

jobs:
  copilot-setup-steps:
    # ...

    # You can define any steps you want, and they will run before the agent starts.
    # If you do not check out your code, Copilot will do this for you.
    steps:
      - name: Checkout code
        uses: actions/checkout@v6

      - name: Set up Node.js
        uses: actions/setup-node@v7
        with:
          node-version: "20"
          cache: "npm"

      - name: Install JavaScript dependencies
        run: npm ci
```

--------------------------------

### copilot completion usage examples for bash, zsh, and fish

Source: https://docs.github.com/en/copilot/reference/copilot-cli-reference/cli-command-reference

Commands to enable tab completion for copilot subcommands, options, and known value choices. The bash examples cover a current session and persistent setup on Linux; the zsh example writes to a directory on $fpath and requires a shell restart; the fish example writes to the fish completions directory.

```bash
source <(copilot completion bash)
```

```bash
copilot completion bash | sudo tee /etc/bash_completion.d/copilot
```

```shell
copilot completion zsh > "${fpath[1]}/_copilot"
```

```shell
copilot completion fish > ~/.config/fish/completions/copilot.fish
```

--------------------------------

### Start interactive session and ask a question

Source: https://docs.github.com/en/copilot/get-started/cli-quickstart

Start an interactive Copilot CLI session, then enter /login to authenticate on first use. After confirming trust in the current directory, you can ask questions like the example prompt. Copilot won't change files without your explicit approval.

```bash
copilot
```

```copilot
Give me an overview of this project.
```

--------------------------------

### Install Copilot CLI with npm

Source: https://docs.github.com/en/copilot/how-tos/copilot-cli/automate-copilot-cli/automate-with-actions

Sets up Node.js and installs GitHub Copilot CLI globally using npm.

```yaml
- name: Set up Node.js environment
  uses: actions/setup-node@v7

- name: Install Copilot CLI
  run: npm install -g @github/copilot
```

--------------------------------

### Java: Create session and send prompt with CopilotClient

Source: https://docs.github.com/en/copilot/how-tos/copilot-sdk/setup/bundled-cli

Uses the Java SDK to create a client with a specified CLI path, start it, create a session with model gpt-5.4 and auto-approve permissions, send a prompt, and print the response. The Java SDK does not bundle the CLI; install it separately and set its path with setCliPath(...).

```java
import com.github.copilot.CopilotClient;
import com.github.copilot.rpc.*;

var client = new CopilotClient(new CopilotClientOptions()
    // Point to the CLI binary installed on the system
    .setCliPath("/path/to/vendor/copilot")
);
client.start().get();

var session = client.createSession(new SessionConfig()
    .setModel("gpt-5.4")
    .setOnPermissionRequest(PermissionHandler.APPROVE_ALL)
).get();

var response = session.sendAndWait(new MessageOptions()
    .setPrompt("Hello!")).get();
System.out.println(response.getData().content());

client.stop().get();
```

--------------------------------

### Example README template generated by Copilot Chat

Source: https://docs.github.com/en/copilot/tutorials/copilot-cookbook/communicate-effectively/creating-templates

This is an example response from Copilot Chat. It provides a structured README template with sections for description, installation, usage, contributing, license, and contact. The response is non-deterministic, so actual output may vary.

```markdown
# Project Name

> **Short description:**  
> A brief summary of what your project does, its main features, and its purpose.

---

## Table of Contents

- [Description](#description)
- [Installation](#installation)
- [Usage](#usage)
- [Contributing](#contributing)
- [License](#license)
- [Contact](#contact)

---

## Description

Provide a detailed explanation of what your project does, why it exists, and any important background information.  
You may want to include:
- Key features
- Supported platforms or languages
- Screenshots or diagrams

---

## Installation

1. **Clone the repository**
   ```sh
   git clone https://github.com/your-username/your-repo-name.git
   cd your-repo-name
   ```

2. **Install dependencies**
   ```sh
   # Example for Node.js projects
   npm install

   # Example for Python projects
   pip install -r requirements.txt
   ```

3. **Additional setup**
   - List any other required steps (e.g., environment variables, configuration files)

---

## Usage

Provide clear usage instructions and code examples.

```sh
# Example command
your-command --option value
```

```python
# Example in Python
import your_module

result = your_module.do_something()
print(result)
```

- Explain any CLI options, configuration, or parameters.
- Link to more detailed documentation if available.

---

## Contributing

Contributions are welcome! Please follow these guidelines:

1. **Fork the repository**
2. **Create a new branch**
   ```sh
   git checkout -b feature/your-feature-name
   ```
3. **Make your changes**
4. **Test your changes**
5. **Commit and push**
   ```sh
   git commit -m "Add feature: your-feature-name"
   git push origin feature/your-feature-name
   ```
6. **Open a pull request**

**Code of Conduct:**  
Please be respectful and follow our [Code of Conduct](CODE_OF_CONDUCT.md).

**Issues & Suggestions:**  
Open an issue for bugs, questions, or feature requests.

---

## License

This project is licensed under the [INSERT LICENSE](link to relevant license information).

---

## Contact

- **Maintainer:** [Your Name](mailto:your@email.com)
- **Project Link:** https://github.com/your-username/your-repo-name

---
```

--------------------------------

### Create session with hooks in Java

Source: https://docs.github.com/en/copilot/how-tos/copilot-sdk/hooks/hooks-overview

Java example showing how to create a Copilot session with hooks for pre-tool, post-tool, and session start events. Uses SessionHooks, PreToolUseHookOutput.allow(), and SessionStartHookOutput. Requires a running CopilotClient and uses APPROVE_ALL permission handler.

```java
import com.github.copilot.*;
import com.github.copilot.rpc.*;
import java.util.concurrent.CompletableFuture;

try (var client = new CopilotClient()) {
    client.start().get();

    var hooks = new SessionHooks()
        .setOnPreToolUse((input, invocation) -> {
            System.out.println("Tool called: " + input.getToolName());
            return CompletableFuture.completedFuture(PreToolUseHookOutput.allow());
        })
        .setOnPostToolUse((input, invocation) -> {
            System.out.println("Tool result: " + input.getToolResult());
            return CompletableFuture.completedFuture(null);
        })
        .setOnSessionStart((input, invocation) -> {
            return CompletableFuture.completedFuture(
                new SessionStartHookOutput("User prefers concise answers.", null)
            );
        });

    var session = client.createSession(
        new SessionConfig()
            .setHooks(hooks)
            .setOnPermissionRequest(PermissionHandler.APPROVE_ALL)
    ).get();
}
```

--------------------------------

### Install Copilot SDK for Python

Source: https://docs.github.com/en/copilot/get-started/sdk-quickstart

Installs the Copilot SDK for Python.

```bash
pip install github-copilot-sdk
```

--------------------------------

### Example .github/copilot-instructions.md

Source: https://docs.github.com/en/copilot/concepts/prompting/response-customization?tool=jetbrains

A sample repository custom instructions file with three instructions: using Bazel for Java dependencies, JavaScript style with double quotes and tabs, and Jira for work tracking.

```markdown
We use Bazel for managing our Java dependencies, not Maven, so when talking about Java packages, always give me instructions and code samples that use Bazel.

We always write JavaScript with double quotes and tabs for indentation, so when your responses include JavaScript code, please follow those conventions.

Our team uses Jira for tracking items of work.

```

--------------------------------

### Install Copilot SDK for Go

Source: https://docs.github.com/en/copilot/get-started/sdk-quickstart

Creates a new directory, initializes a Go module, and installs the Copilot SDK for Go.

```bash
mkdir copilot-demo && cd copilot-demo
go mod init copilot-demo
```

```bash
go get github.com/github/copilot-sdk/go
```

--------------------------------

### main.py - entry point for example project

Source: https://docs.github.com/en/copilot/tutorials/copilot-cookbook/refactor-code/handle-cross-cutting

Entry point that sets up logging and instantiates service classes. It demonstrates the current scattered logging approach where each service logs its own information.

```python
import logging
from logging_config import setup_logging
from payment_service import PaymentService
from order_service import OrderService
from shipping_service import ShippingService
from inventory_service import InventoryService
from notification_service import NotificationService

def main():
    setup_logging()
    payment_service = PaymentService()
    order_service = OrderService()
    shipping_service = ShippingService()
    inventory_service = InventoryService()
    notification_service = NotificationService()

    # Example usage
    payment_service.process_payment({"amount": 100, "currency": "USD"})
    order_service.place_order({"item": "Book", "quantity": 1})
    shipping_service.ship_order({"item": "Book", "quantity": 1})
    inventory_service.update_inventory("Book", -1)
    notification_service.send_notification("Order has been placed and shipped.")

if __name__ == "__main__":
    main()
```

--------------------------------

### Example .github/copilot-instructions.md

Source: https://docs.github.com/en/copilot/how-tos/copilot-on-github/use-copilot-agents/copilot-code-review

Example of a repository-wide custom instructions file with three review instructions: respond in Spanish, apply security checklist, and focus on readability.

```text
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.
```

--------------------------------

### copilot skill add, enable, disable, remove

Source: https://docs.github.com/en/copilot/reference/copilot-cli-reference/cli-command-reference

Manage skills from the command line without an interactive session. The first command installs a skill for your user account (default). The second installs a skill into the current project (.github/skills; file or URL skills only). The third enables, disables, or removes a skill by name.

```bash
copilot skill add ./my-skill/SKILL.md
```

```bash
copilot skill add --project ./my-skill/SKILL.md
```

```bash
copilot skill enable my-skill
copilot skill disable my-skill
copilot skill remove my-skill
```

--------------------------------

### copilot login authentication examples

Source: https://docs.github.com/en/copilot/reference/copilot-cli-reference/cli-command-reference

Examples of authenticating with GitHub Copilot CLI. The default flow is browser-based on local terminals and device code on remote terminals or CI; use --web-flow or --device-code to override. Tokens can be read from standard input with --with-token or provided via environment variables (COPILOT_GITHUB_TOKEN, GH_TOKEN, GITHUB_TOKEN).

```shell
# Authenticate with github.com
copilot login
```

```shell
# Authenticate with GitHub Enterprise Cloud (data residency)
copilot login --host https://example.ghe.com
```

```shell
# Force the device code flow, for example on a remote terminal
copilot login --device-code
```

```shell
# Force the browser (web) flow, for example on a local terminal
copilot login --web-flow
```

```shell
# Read a token from standard input, bypassing the OAuth flow entirely
copilot login --with-token < mytoken.txt
```

```shell
# Use a fine-grained PAT via environment variable
COPILOT_GITHUB_TOKEN=github_pat_... copilot
```

--------------------------------

### List configured language servers with copilot lsp list

Source: https://docs.github.com/en/copilot/reference/copilot-cli-reference/cli-command-reference

Lists configured language servers. The --json option emits JSON instead of text. This command replaces the retired 'copilot plugins list --kind lsp' and is inspect-only; use the /lsp slash command in an interactive session to start, stop, or reload a language server.

```bash
copilot lsp list
copilot lsp list --json
```

--------------------------------

### Example: /after with 10-minute delay

Source: https://docs.github.com/en/copilot/how-tos/copilot-cli/automate-copilot-cli/schedule-prompts

This example schedules a prompt to run after 10 minutes, checking that the address finder is visible on example.com/register.

```copilot
/after 10m Check that the address finder is visible on example.com/register
```

--------------------------------

### Run a dynamic workflow with copilot workflow run

Source: https://docs.github.com/en/copilot/reference/copilot-cli-reference/cli-command-reference

Run a dynamic workflow provided by an extension without opening an interactive session. WORKFLOW-NAME is the name registered by the extension, not a path to an extension file. The command starts a run and waits for it to finish, pause, or otherwise stop.

```shell
copilot workflow run WORKFLOW-NAME [OPTIONS]
```

--------------------------------

### copilot workflow run

Source: https://docs.github.com/en/copilot/reference/copilot-cli-reference/cli-command-reference

Runs a dynamic workflow provided by an extension without opening an interactive session. The command starts a run and waits for it to finish, pause, or otherwise stop.

```APIDOC
## copilot workflow run

### Description
Runs a dynamic workflow provided by an extension without opening an interactive session. The command starts a run and waits for it to finish, pause, or otherwise stop.

### Command
`copilot workflow run WORKFLOW-NAME [OPTIONS]`

### Parameters
#### Positional Arguments
- **WORKFLOW-NAME** (string) - Required - The name registered by the extension, not a path to an extension file.

#### Options
- **--args JSON** or **--args @PATH** (string) - Optional - Supply the workflow's inputs. Replace "JSON" with inline JSON, or "PATH" with the path to a UTF-8 JSON file. Defaults to `{}` when omitted. The accepted inputs depend on the workflow.
- **--result-file PATH** (string) - Optional - Write the returned value as JSON to a file instead of including it in standard output. Written only when the workflow completes and returns a result. An existing file is replaced only after the new result has been written successfully.
- **-s**, **--silent** (boolean) - Optional - Suppress progress output. The final result is still emitted unless directed to a file. Error and status diagnostics may still appear on standard error.
- **--output-format FORMAT** (string) - Optional - Set the standard output format to `text` (default) or `json` (JSONL, one JSON record per line). Combine `json` with `--silent` to receive only the final workflow record. Does not change the JSON format of `--result-file`.

### Usage Notes
- Relative argument-file and result-file paths are resolved from the working directory.
- Without `--silent`, output includes phases and progress messages reported by the workflow.
- The command uses the CLI's authentication, model, permission, and sandbox settings. Permission options such as `--allow-tool` and `--allow-url` apply to the workflow's agents. It does not display permission approval prompts.
- Prompt and session-mode options cannot be combined with this command. Examples include `-p`, `-i`, `--agent`, `--fleet`, `--autopilot`, `--resume`, and `--continue`. Piped standard input is not used as a prompt or as workflow arguments.

### Example
```shell copy
copilot workflow run WORKFLOW-NAME [OPTIONS]
```

```

--------------------------------

### Example plan output from GitHub Copilot CLI

Source: https://docs.github.com/en/copilot/tutorials/copilot-cookbook/generate-code/implement-a-feature

Example plan returned by GitHub Copilot CLI. It outlines steps to add a method, route, OpenAPI spec, tests, and run the test suite. Responses are non-deterministic.

```text
1. Add a `getPlanForSubscription` method in `src/services/subscriptionService.ts` that reuses the existing billing client, throws `NotFoundError` when the subscription or plan does not exist, and throws `CancelledSubscriptionError` when the subscription has been cancelled.
1. Add a `GET /subscriptions/:id/plan` route in `src/routes/subscriptions.ts`, mirroring the error handling in the sibling `GET /subscriptions/:id` route and mapping `CancelledSubscriptionError` to a `410` response.
1. Update `openapi/subscriptions.yaml` with the new path, response schema, and `404` and `410` responses.
1. Add unit tests in `test/services/subscriptionService.test.ts` and `test/routes/subscriptions.test.ts` covering the success case, missing subscription, cancelled subscription, and missing plan.
1. Run the test suite and update the changelog entry.
```

--------------------------------

### Scope a Claude Code rule with paths frontmatter

Source: https://docs.github.com/en/copilot/reference/copilot-cli-reference/cli-command-reference

Frontmatter keys `paths` (or `applyTo`) scope a rule to matching files. This example scopes the rule to TypeScript files under `src/api/` and provides a description for the rule.

```markdown
---
paths: "src/api/**/*.ts"
description: API layer conventions
---

Use the shared `ApiError` type for all thrown errors in this directory.
```

--------------------------------

### Example of paths specified in the repository settings

Source: https://docs.github.com/en/copilot/how-tos/configure-content-exclusion/exclude-content-from-copilot

Example of paths specified in the repository settings for content exclusion. Each path is on a separate line, comments start with `#`, and fnmatch pattern matching notation is supported (case insensitive).

```yaml
# Ignore the `/src/some-dir/kernel.rs` file in this repository.
- "/src/some-dir/kernel.rs"

# Ignore files called `secrets.json` anywhere in this repository.
- "secrets.json"

# Ignore all files whose names begin with `secret` anywhere in this repository.
- "secret*"

# Ignore files whose names end with `.cfg` anywhere in this repository.
- "*.cfg"

# Ignore all files in or below the `/scripts` directory of this repository.
- "/scripts/**"
```

--------------------------------

### Example: Frontend-specific instructions (frontend.instructions.md)

Source: https://docs.github.com/en/copilot/tutorials/customize-code-review

Create a `frontend.instructions.md` file in the `.github/instructions` directory with the `applyTo` frontmatter property set to `src/components/**/*.{tsx,jsx}` to apply React component guidelines, state management practices, and accessibility standards to frontend components.

```text
---
applyTo: "src/components/**/*.{tsx,jsx}"
---

# React Component Guidelines

## Component Structure

- Use functional components with hooks
- Keep components small and focused (under 200 lines)
- Extract reusable logic into custom hooks

## State Management

- Use useState for local component state
- Use useContext for shared state across components
- Avoid prop drilling beyond 2-3 levels

## Accessibility

- All interactive elements must be keyboard accessible
- Include appropriate ARIA labels
- Ensure color contrast meets WCAG AA standards
```

--------------------------------

### Start general, then get specific: JavaScript prime function prompt

Source: https://docs.github.com/en/copilot/concepts/prompting/prompt-engineering

Start with a broad goal, then add specific requirements. This prompt asks for a JavaScript prime-checking function with explicit input, return, and error conditions.

```copilot
Write a JavaScript function that tells me if a number is prime

The function should take an integer and return true if the integer is prime

The function should error if the input is not a positive integer
```

--------------------------------

### Connect SDK in Python

Source: https://docs.github.com/en/copilot/how-tos/copilot-sdk/setup/backend-services

Creates a CopilotClient with a runtime connection to localhost:4321, starts the client, creates a session with an approve-all permission handler and model gpt-5.4, then sends a message and waits for the response.

```python
from copilot import CopilotClient, RuntimeConnection
from copilot.session import PermissionHandler

client = CopilotClient(
    connection=RuntimeConnection.for_uri("localhost:4321"),
)
await client.start()

session = await client.create_session(on_permission_request=PermissionHandler.approve_all, model="gpt-5.4", session_id=f"user-{user_id}-{int(time.time())}")

response = await session.send_and_wait(message)
```

--------------------------------

### Sequential workflow with Copilot and OpenAI agents (Java)

Source: https://docs.github.com/en/copilot/how-tos/copilot-sdk/integrations/microsoft-agent-framework

Use the Java SDK directly to create a code-review session and a documentation session, chaining the review output into the documentation prompt. The example prints the final documentation and stops the client. Requires the GitHub Copilot Java SDK.

```java
import com.github.copilot.CopilotClient;
import com.github.copilot.rpc.*;

// Java uses the standard SDK directly — no MAF orchestrator needed
var client = new CopilotClient();
client.start().get();

// Step 1: Code review session
var reviewer = client.createSession(new SessionConfig()
    .setModel("gpt-5.4")
    .setOnPermissionRequest(PermissionHandler.APPROVE_ALL)
).get();

var review = reviewer.sendAndWait(new MessageOptions()
    .setPrompt("Review this PR for bugs, security issues, and best practices: "
        + "added retry logic to the HTTP client")).get();

// Step 2: Documentation session using review output
var documentor = client.createSession(new SessionConfig()
    .setModel("gpt-5.4")
    .setOnPermissionRequest(PermissionHandler.APPROVE_ALL)
).get();

var docs = documentor.sendAndWait(new MessageOptions()
    .setPrompt("Write documentation for these changes: " + review.getData().content())).get();
System.out.println(docs.getData().content());

client.stop().get();
```

--------------------------------

### Example: Python-specific instructions (python.instructions.md)

Source: https://docs.github.com/en/copilot/tutorials/customize-code-review

Create a `python.instructions.md` file in the `.github/instructions` directory with the `applyTo` frontmatter property set to `**/*.py` to apply Python-specific coding conventions, style rules, and best practices to Python files.

```text
---
applyTo: "**/*.py"
---

# Python Coding Conventions

## Naming Conventions

- Use snake_case for variables and functions
- Use PascalCase for class names
- Use UPPERCASE for constants

## Code Style

- Follow PEP 8 style guidelines
- Limit line length to 88 characters (Black formatter standard)
- Use type hints for function signatures

## Best Practices

- Use list comprehensions for simple transformations
- Prefer f-strings for string formatting
- Use context managers (with statements) for resource management

```python
# Avoid
file = open('data.txt')
content = file.read()
file.close()

# Prefer
with open('data.txt') as file:
    content = file.read()
```
```

--------------------------------

### Example unit test suite for BankAccount

Source: https://docs.github.com/en/copilot/tutorials/write-tests

This is an example of a unit test suite that Copilot might generate for the BankAccount class. It imports unittest and BankAccount, and includes a setUp method and a test for the initial balance. The generated tests may not cover all scenarios, so review and add additional tests as needed.

```python
import unittest
from bank_account import BankAccount

class TestBankAccount(unittest.TestCase):
    def setUp(self):
        self.account = BankAccount()

    def test_initial_balance(self):
        self.assertEqual(self.account.get_balance(), 0)
```

--------------------------------

### Connect to existing MCP server

Source: https://docs.github.com/en/copilot/how-tos/copilot-sdk/troubleshooting/debugging

Connects the CopilotClient to an already running MCP server via its URL. Use this when the server is started separately, for example in TCP mode.

```typescript
const client = new CopilotClient({
  cliUrl: "localhost:8080",  // Connect to running server
});
```

--------------------------------

### Prompt to create copilot-setup-steps.yml

Source: https://docs.github.com/en/copilot/tutorials/cloud-agent/improve-a-project

Copy and paste this prompt into the Copilot cloud agent dialog to have it analyze the repository and create a copilot-setup-steps.yml workflow file. The prompt specifies that the workflow must be named copilot-setup-steps and include a workflow_dispatch trigger.

```text
Analyze this repository to understand the dependencies that need to be installed on the development environment to work on the code in this repository. Using this information, and the details about the `copilot-setup-steps.yml` file that are given in https://docs.github.com/copilot/how-tos/use-copilot-agents/cloud-agent/customize-the-agent-environment, add a `.github/workflows/copilot-setup-steps.yml` to this repository. This Actions workflow file should install, in the development environment for Copilot cloud agent, all of the dependencies necessary to work on the code in this repository. Make sure that the workflow job is named `copilot-setup-steps`, and that the workflow includes a `workflow_dispatch` trigger so that it can be run manually. Choose any other triggers to suit this repository; there's no need to run on both `push` and `pull_request`.
```

--------------------------------

### Deep inheritance hierarchy in C#

Source: https://docs.github.com/en/copilot/tutorials/copilot-cookbook/refactor-code/simplify-inheritance-hierarchies

A C# example of a deep inheritance hierarchy where each class inherits from the previous one, leading to a long chain that is difficult to understand and maintain. This is the starting point for the refactoring prompt.

```csharp
public class Employee
{
    public string Name { get; set; }
    public int EmployeeID { get; set; }
}

public class Manager : Employee
{
    public int NumberOfTeams { get; set; }
}

public class SeniorManager : Manager
{
    public string Region { get; set; }
}

public class Director : SeniorManager
{
    public int NumberOfDepartments { get; set; }
}

public class VicePresident : Director
{
    public string Division { get; set; }
}

public class President : VicePresident
{
    public string Company { get; set; }
}
```

--------------------------------

### Stream agent responses with MAF in .NET

Source: https://docs.github.com/en/copilot/how-tos/copilot-sdk/integrations/microsoft-agent-framework

Use this .NET example to stream agent responses with the MAF integration. It creates a CopilotClient, starts it, and runs a streaming request with the AIAgent, printing each chunk to the console.

```csharp
using GitHub.Copilot;
using Microsoft.Agents.AI;

await using var copilotClient = new CopilotClient();
await copilotClient.StartAsync();

AIAgent agent = copilotClient.AsAIAgent(new AIAgentOptions
{
    Streaming = true,
});

await foreach (var chunk in agent.RunStreamingAsync("Write a quicksort implementation in C#"))
{
    Console.Write(chunk);
}
Console.WriteLine();
```

--------------------------------

### /chronicle tips example output

Source: https://docs.github.com/en/copilot/how-tos/copilot-cli/use-copilot-cli/chronicle

Example main points from a /chronicle tips response, showing personalized recommendations based on real usage data.

```text
1. Use @ to mention files instead of pasting content
2. Iterate within a session — don't start over
3. Try /research for your exploration work
4. Turn recurring prompts into a custom agent
5. Use plan mode for multi-step work
```

--------------------------------

### Example dependabot.yml for pip and GitHub Actions

Source: https://docs.github.com/en/copilot/tutorials/copilot-cookbook/analyze-security/manage-dependency-updates

Example dependabot.yml configuration generated by Copilot Chat. It enables weekly security and version updates for pip and GitHub Actions ecosystems, with schedules, pull request limits, commit message prefixes, labels, and an ignore rule for pip self-updates. Commit this file to the repository to start receiving Dependabot pull requests.

```yaml
version: 2
updates:
  # Python (pip)
  - package-ecosystem: "pip"
    directory: "/"                     # Location of requirements.txt
    schedule:
      interval: "weekly"               # Weekly updates are a good balance for libraries
      day: "sunday"
      time: "06:00"
      timezone: "UTC"
    open-pull-requests-limit: 5
    allow:
      - dependency-type: "all"
    commit-message:
      prefix: "pip"
    labels:
      - "dependencies"
      - "python"
    ignore:
      - dependency-name: "pip"         # Ignore pip self-updates

  # GitHub Actions
  - package-ecosystem: "github-actions"
    directory: "/"                     # Looks for workflow files under .github/workflows/
    schedule:
      interval: "weekly"
      day: "sunday"
      time: "06:00"
      timezone: "UTC"
    open-pull-requests-limit: 5
    commit-message:
      prefix: "actions"
    labels:
      - "dependencies"
      - "github-actions"
```

--------------------------------

### Create a copilot-setup-steps.yml workflow

Source: https://docs.github.com/en/copilot/how-tos/copilot-on-github/customize-copilot/customize-cloud-agent/customize-the-agent-environment

Example of a copilot-setup-steps.yml workflow file for a TypeScript project. The job must be named `copilot-setup-steps` and only `steps`, `permissions`, `runs-on`, `services`, `snapshot`, and `timeout-minutes` (max 59) can be customized; other settings are ignored. The workflow only triggers when present on the default branch, and any `fetch-depth` set for `actions/checkout` is overridden.

```yaml
name: "Copilot Setup Steps"

# Automatically run the setup steps when they are changed to allow for easy validation, and
# allow manual testing through the repository's "Actions" tab
on:
  workflow_dispatch:
  push:
    paths:
      - .github/workflows/copilot-setup-steps.yml
  pull_request:
    paths:
      - .github/workflows/copilot-setup-steps.yml

jobs:
  # The job MUST be called `copilot-setup-steps` or it will not be picked up by Copilot.
  copilot-setup-steps:
    runs-on: ubuntu-latest

    # Set the permissions to the lowest permissions possible needed for your steps.
    # Copilot will be given its own token for its operations.
    permissions:
      # If you want to clone the repository as part of your setup steps, for example to install dependencies, you'll need the `contents: read` permission.
      # If you don't clone the repository in your setup steps, Copilot will do this for you automatically after the steps complete.
      contents: read

    # You can define any steps you want, and they will run before the agent starts.
    # If you do not check out your code, Copilot will do this for you.
    steps:
      # ...
```

--------------------------------

### Go: Create session with SkillDirectories

Source: https://docs.github.com/en/copilot/how-tos/copilot-sdk/features/skills

Use the copilot.NewClient to create a session with SkillDirectories. The client must be started and stopped. The OnPermissionRequest callback returns PermissionDecisionApproveOnce. Errors are handled with log.Fatal.

```go
package main

import (
    "context"
    "log"
    copilot "github.com/github/copilot-sdk/go"
    "github.com/github/copilot-sdk/go/rpc"
)

func main() {
    ctx := context.Background()
    client := copilot.NewClient(nil)
    if err := client.Start(ctx); err != nil {
        log.Fatal(err)
    }
    defer client.Stop()

    session, err := client.CreateSession(ctx, &copilot.SessionConfig{
        Model: "gpt-5.4",
        SkillDirectories: []string{
            "./skills/code-review",
            "./skills/documentation",
        },
        OnPermissionRequest: func(req copilot.PermissionRequest, inv copilot.PermissionInvocation) (rpc.PermissionDecision, error) {
            return &rpc.PermissionDecisionApproveOnce{}, nil
        },
    })
    if err != nil {
        log.Fatal(err)
    }

    // Copilot now has access to skills in those directories
    _, err = session.SendAndWait(ctx, copilot.MessageOptions{
        Prompt: "Review this code for security issues",
    })
    if err != nil {
        log.Fatal(err)
    }
}
```

--------------------------------

### Create Copilot session with hooks in Python

Source: https://docs.github.com/en/copilot/how-tos/copilot-sdk/hooks/hooks-overview

Python example of creating a Copilot session with hooks. Uses PermissionHandler.approve_all for permission requests and defines async hooks for pre-tool use, post-tool use, and session start.

```python
from copilot import CopilotClient
from copilot.session import PermissionHandler

async def main():
    client = CopilotClient()
    await client.start()

    async def on_pre_tool_use(input_data, invocation):
        print(f"Tool called: {input_data['toolName']}")
        return {"permissionDecision": "allow"}

    async def on_post_tool_use(input_data, invocation):
        print(f"Tool result: {input_data['toolResult']}")
        return None

    async def on_session_start(input_data, invocation):
        return {"additionalContext": "User prefers concise answers."}

    session = await client.create_session(on_permission_request=PermissionHandler.approve_all, hooks={
            "on_pre_tool_use": on_pre_tool_use,
            "on_post_tool_use": on_post_tool_use,
            "on_session_start": on_session_start,
        })
```

--------------------------------

### Example: /after with 30-minute delay

Source: https://docs.github.com/en/copilot/how-tos/copilot-cli/automate-copilot-cli/schedule-prompts

This example schedules a prompt to run after 30 minutes, asking for details of changes to README.md made in the last 30 minutes.

```copilot
/after 30m Give me details of changes to README.md made in the last 30 minutes
```

--------------------------------

### Example: /after scheduling a skill

Source: https://docs.github.com/en/copilot/how-tos/copilot-cli/automate-copilot-cli/schedule-prompts

This example schedules a skill using /after with a 2-hour delay, instructing Copilot to use the docx skill to create a new file summarizing recent changes to the repo.

```copilot
/after 2h Use the docx skill to create a new file summarizing recent changes to this repo
```

--------------------------------

### Prompt coding agent with agentic-workflows skill

Source: https://docs.github.com/en/copilot/how-tos/github-agentic-workflows/creating-github-agentic-workflows

Example prompt to start a coding agent (e.g., Copilot CLI or VS Code agent mode) to create a workflow. Mentions the `agentic-workflows` skill and describes the desired workflow.

```copilot
/agentic-workflows Create a new workflow that creates a daily report on
recent activity in the repository, delivered as
an issue.
```

--------------------------------

### Add instructions to pull request creation with /pr create

Source: https://docs.github.com/en/copilot/how-tos/copilot-cli/use-copilot-cli/manage-pull-requests

Append instructions after /pr create to guide Copilot when generating the pull request title and description. The example shows prefixing the PR title with 'Project X: '.

```copilot
/pr create prefix the PR title 'Project X: '
```
Tokens:
Raw