Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://code.visualstudio.com/docs/copilot/copilot-customization below:

Customize AI responses in VS Code

Chat in Visual Studio Code can give you responses and generate code that matches your coding practices and project requirements, if you give it the right context. Instead of repeatedly adding this information in every chat prompt, you can store this context in files and automatically include it in every chat request. In this article, you learn how to use custom instructions and prompt files to customize AI responses in VS Code.

There are three main ways to customize AI responses in Visual Studio Code:

• Custom instructions: Define common guidelines or rules for tasks like generating code, performing code reviews, or generating commit messages. Custom instructions describe the conditions in which the AI should perform operate (how a task should be done). Learn how to define custom instructions. VS Code can also help you generate a custom instructions file for your workspace that matches your coding practices and project requirements.

  Example scenarios
  • Specify coding practices, preferred technologies, or project requirements, so generated code follows your standards.
  • Set rules for code reviews, such as checking for security vulnerabilities or performance issues.
  • Provide instructions for generating commit messages or pull request titles and descriptions.

• Prompt files: Define reusable prompts for common tasks like generating code or performing a code review. Prompt files are standalone prompts that you can run directly in chat. They describe the task to be performed (what should be done). Optionally, you can include tasks-specific guidelines about how the task should be performed, or you can reference custom instructions in the prompt file. Learn how to create prompt files.

  Example scenarios
  • Create reusable prompts for common coding tasks, such as scaffolding a new component, API route, or generating tests.
  • Define prompts for performing code reviews, such as checking for code quality, security vulnerabilities, or performance issues.
  • Create step-by-step guides for complex processes or project-specific patterns.
  • Define prompts for generating implementation plans, architectural designs, or migration strategies.

• Custom chat modes: Define how chat operates, which tools it can use, and how it interacts with the codebase. Each chat prompt is run within the boundaries of the chat mode, without having to configure tools and instructions for every request.

  Example scenarios
  • Create a chat mode for planning, where the AI has read-only access to the codebase and can only generate implementation plans.
  • Define a research chat mode, where the AI can reach out to external resources to explore new technologies or gather information.
  • Create a front-end developer chat mode, where the AI can only generate and modify code related to front-end development.

Custom instructions enable you to describe common guidelines or rules to get responses that match your specific coding practices and tech stack. Instead of manually including this context in every chat query, custom instructions automatically incorporate this information with every chat request.

VS Code supports multiple ways to define custom instructions:

• Describe code-generation instructions in Markdown.
• All instructions are combined in a single file, stored within the workspace.
• Instructions are automatically included in every chat request.
• Supported across all editors and IDEs that support Copilot.
• Use this file to define general coding practices, preferred technologies, and project requirements that apply to all code-generation tasks.

• Describe code-generation instructions in Markdown.
• Create one or more instructions files, stored in the workspace or your user profile.
• Use glob patterns to automatically include instructions for all requests or for specific files.
• Supported in VS Code.
• Use these files if you want to have task-specific code-generation instructions, and to have more control over when to include instructions with your chat prompt.

• Specify instructions in VS Code user or workspace settings.
• Define instructions in settings values or in one or more files.
• Supported in VS Code.
• Supports instructions for code generation, test generation, commit messages, code review, and PR titles and descriptions.
• Use this option to define instructions for tasks other than code-generation.

You can use a combination of these approaches to define custom instructions and the instructions are all included in the chat request. No particular order or priority is applied to the instructions, so make sure to avoid conflicting instructions in the files.

The following examples demonstrates how to use custom instructions:

---
applyTo: "**"
---
# Project general coding standards

## Naming Conventions
- Use PascalCase for component names, interfaces, and type aliases
- Use camelCase for variables, functions, and methods
- Prefix private class members with underscore (_)
- Use ALL_CAPS for constants

## Error Handling
- Use try/catch blocks for async operations
- Implement proper error boundaries in React components
- Always log errors with contextual information

Notice how these instructions reference the general coding guidelines file. You can separate the instructions into multiple files to keep them organized and focused on specific topics.

---
applyTo: "**/*.ts,**/*.tsx"
---
# Project coding standards for TypeScript and React

Apply the [general coding guidelines](./general-coding.instructions.md) to all code.

## TypeScript Guidelines
- Use TypeScript for all new code
- Follow functional programming principles where possible
- Use interfaces for data structures and type definitions
- Prefer immutable data (const, readonly)
- Use optional chaining (?.) and nullish coalescing (??) operators

## React Guidelines
- Use functional components with hooks
- Follow the React hooks rules (no conditional hooks)
- Use React.FC type for components with children
- Keep components small and focused
- Use CSS modules for component styling

You can store custom instructions in your workspace or repository in a .github/copilot-instructions.md file and describe your coding practices, preferred technologies, and project requirements by using Markdown. These instructions only apply to the workspace where the file is located.

VS Code automatically includes the instructions from the .github/copilot-instructions.md file in every chat request and applies them for generating code.

To use a .github/copilot-instructions.md file:

1. Set the github.copilot.chat.codeGeneration.useInstructionFiles setting to true to instruct VS Code to automatically use the copilot-instructions.md file for every chat request.

2. Create a .github/copilot-instructions.md file at the root of your workspace. If needed, create a .github directory first.

3. Describe your instructions by using natural language and in Markdown format.

   Whitespace between instructions is ignored, so the instructions can be written as a single paragraph, each on a new line, or separated by blank lines for legibility.

GitHub Copilot in Visual Studio and GitHub.com also detect the .github/copilot-instructions.md file. If you have a workspace that you use in both VS Code and Visual Studio, you can use the same file to define custom instructions for both editors.

You can also create one or more .instructions.md files to store custom instructions for specific tasks. For example, you can create instruction files for different programming languages, frameworks, or project types.

VS Code can automatically add instructions files to all chat requests, or you can specify for which files the instructions should be applied automatically. Alternatively, you can manually attach instructions files to a chat prompt.

VS Code supports two types of scopes for instruction files:

• Workspace instructions files: are only available within the workspace and are stored in the .github/instructions folder of the workspace.
• User instruction files: are available across multiple workspaces and are stored in the current VS Code profile.

An instructions file is a Markdown file with the .instructions.md file suffix. The instructions file consists of two sections:

• (Optional) Header with metadata (Front Matter syntax)

  • description: A brief description of the instructions file. This description is displayed when you hover the instructions file in the Chat view.

  • applyTo: Specify a glob pattern for files to which the instructions are automatically applied. To always include the custom instructions, use the ** pattern.

    For example, the following instructions file is always applied:

    ---
    applyTo: "**"
    ---
    Add a comment at the end of the file: 'Contains AI-generated edits.'
    

• Body with the instruction content

  Specify the custom instructions in natural language by using Markdown formatting. You can use headings, lists, and code blocks to structure the instructions.

  You can reference other instruction files by using Markdown links. Use relative paths to reference these files, and ensure that the paths are correct based on the location of the instruction file.

You can create instructions files in your workspace or user profile. Workspace instructions files are only available within the workspace, while user instructions files are available across multiple workspaces.

To create an instructions file:

1. Select the Configure Chat button in the Chat view, select Instructions, and then select New instruction file.

   Alternatively, use the Chat: New Instructions File command from the Command Palette (⇧⌘P (Windows, Linux Ctrl+Shift+P)).

2. Choose the location where the instruction file should be created.

   • Workspace: By default, workspace instruction files are stored in the .github/instructions folder of your workspace. Add more instruction folders for your workspace with the chat.instructionsFilesLocations setting.

   • User profile: User instruction files are stored in the current profile folder. You can sync your user instruction files across multiple devices by using Settings Sync.

3. Enter a name for your instruction file.

4. Author the custom instructions by using Markdown formatting.

   Specify the applyTo metadata property in the header to configure when the instructions should be applied automatically. For example, you can specify applyTo: "**/*.ts,**/*.tsx" to apply the instructions only to TypeScript files.

   To reference additional workspace files, use Markdown links ([index](../index.ts)) or #-reference them (#index.ts) within the instructions file.

To modify an existing instructions file, select the Configure Chat button in the Chat view, select Instructions, and then select an instructions file from the list. Alternatively, use the Chat: Configure Instructions command from the Command Palette (⇧⌘P (Windows, Linux Ctrl+Shift+P)) and select the instructions file from the Quick Pick.

If you specified the applyTo metadata property in the instructions file, VS Code automatically applies the instructions to all files that match the glob pattern.

To manually attach an instructions file to a chat prompt:

• In the Chat view, select Add Context > Instructions and select the instruction file from the Quick Pick.

• Run the Chat: Attach Instructions command from the Command Palette (⇧⌘P (Windows, Linux Ctrl+Shift+P)) and select the instruction file from the Quick Pick.

You can configure custom instructions for specialized scenarios in your user or workspace settings.

* The codeGeneration and testGeneration settings are deprecated as of VS Code 1.102. We recommend that you use instructions files instead (.github/copilot-instructions.md or *.instructions.md).

You can define the custom instructions as text in the settings value (text property) or reference an external file (file property) in your workspace.

The following code snippet shows how to define a set of instructions in the settings.json file.

    "github.copilot.chat.pullRequestDescriptionGeneration.instructions": [
        { "text": "Always include a list of key changes." },
    "github.copilot.chat.reviewSelection.instructions": [
        { "file": "guidance/backend-review-guidelines.md" },
        { "file": "guidance/frontend-review-guidelines.md" }
  ]

VS Code can analyze your workspace and generate a matching .github/copilot-instructions.md file with custom instructions that match your coding practices and project requirements.

To generate an instructions file for your workspace:

1. Select the Configure Chat button in the Chat view and select Instructions

2. Select Generate instructions from the Quick Pick.

3. Review the generated instructions file and make any necessary edits.

• Keep your instructions short and self-contained. Each instruction should be a single, simple statement. If you need to provide multiple pieces of information, use multiple instructions.

• Don't refer to external resources in the instructions, such as specific coding standards.

• Split instructions into multiple files. This approach is useful for organizing instructions by topic or type of task.

• Make it easy to share custom instructions with your team or across projects by storing your instructions in instruction files. You can also version control the files to track changes over time.

• Use the applyTo property in the instruction file header to automatically apply the instructions to specific files or folders.

• Reference custom instructions in your prompt files to keep your prompts clean and focused, and to avoid duplicating instructions for different tasks.

Prompt files are reusable prompts for common tasks like generating code or performing a code review. You define the prompt content in a Markdown file. A prompt file is a standalone prompt that you can run directly in chat. Optionally, you can also include guidelines about how the task should be performed.

Prompt files can take advantage of instruction files to reuse common guidelines and have task-specific instructions included in the prompt. For example, a security review prompt file can reference a custom instructions that describe general security practices, while also including specific instructions on how to report the findings of the review.

VS Code supports two types of scopes for prompt files:

• Workspace prompt files: Are only available within the workspace and are stored in the .github/prompts folder of the workspace.
• User prompt files: Are available across multiple workspaces and are stored in the current VS Code profile.

The following examples demonstrate how to use prompt files:

---
mode: 'agent'
model: GPT-4o
tools: ['githubRepo', 'codebase']
description: 'Generate a new React form component'
---
Your goal is to generate a new React form component based on the templates in #githubRepo contoso/react-templates.

Ask for the form name and fields if not provided.

Requirements for the form:
* Use form design system components: [design-system/Form.md](../docs/design-system/Form.md)
* Use `react-hook-form` for form state management:
* Always define TypeScript types for your form data
* Prefer *uncontrolled* components using register
* Use `defaultValues` to prevent unnecessary rerenders
* Use `yup` for validation:
* Create reusable validation schemas in separate files
* Use TypeScript types to ensure type safety
* Customize UX-friendly validation rules

---
mode: 'ask'
model: Claude Sonnet 4
description: 'Perform a REST API security review'
---
Perform a REST API security review and provide a TODO list of security issues to address.

* Ensure all endpoints are protected by authentication and authorization
* Validate all user inputs and sanitize data
* Implement rate limiting and throttling
* Implement logging and monitoring for security events

Return the TODO list in a Markdown format, grouped by priority and issue type.

A prompt file is a Markdown file with the .prompt.md file suffix. It has the following two main sections:

• (Optional) Header with metadata (Front Matter syntax)

  • mode: The chat mode to use when running the prompt: ask, edit, or agent (default).
  • model: The AI model to use when running the prompt. If not specified, the currently selected model in model picker is used.
  • tools: Array of tool (set) names to indicate which tools (sets) can be used in agent mode. Select Configure Tools to select the tools from the list of available tools in your workspace. If a given tool (set) is not available when running the prompt, it is ignored.
  • description: A short description of the prompt.

• Body with the prompt content

  Prompt files mimic the format of writing prompts in chat. This allows blending natural language instructions, additional context, and even linking to other prompt files as dependencies. You can use Markdown formatting to structure the prompt content, including headings, lists, and code blocks.

You can reference other workspace files, prompt files, or instructions files by using Markdown links. Use relative paths to reference these files, and ensure that the paths are correct based on the location of the prompt file.

Within a prompt file, you can reference variables by using the ${variableName} syntax. You can reference the following variables:

• Workspace variables - ${workspaceFolder}, ${workspaceFolderBasename}
• Selection variables - ${selection}, ${selectedText}
• File context variables - ${file}, ${fileBasename}, ${fileDirname}, ${fileBasenameNoExtension}
• Input variables - ${input:variableName}, ${input:variableName:placeholder} (pass values to the prompt from the chat input field)

You can create prompt files in your workspace or user profile. Workspace prompt files are only available within the workspace, while user prompt files are available across multiple workspaces.

To create a prompt file:

1. Select the Configure Chat button in the Chat view, select Prompt Files, and then select New prompt file.

   Alternatively, use the Chat: New Prompt File command from the Command Palette (⇧⌘P (Windows, Linux Ctrl+Shift+P)).

2. Choose the location where the prompt file should be created.

   • Workspace: By default, workspace prompt files are stored in the .github/prompts folder of your workspace. Add more prompt folders for your workspace with the chat.promptFilesLocations setting.

   • User profile: User prompt files are stored in the current profile folder. You can sync your user prompt files across multiple devices by using Settings Sync.

3. Enter a name for your prompt file.

   Alternatively, you can directly create a .prompt.md file in the prompts folder of your workspace.

4. Author the chat prompt by using Markdown formatting.

   Within a prompt file, reference additional workspace files as Markdown links ([index](../index.ts)), or as #index.ts references within the prompt file.

   You can also reference other .prompt.md files to create a hierarchy of prompts. You can also reference instructions files in the same way.

To modify an existing prompt file, select the Configure Chat button in the Chat view, select Prompt Files, and then select a prompt file from the list. Alternatively, use the Chat: Configure Prompt Files command from the Command Palette (⇧⌘P (Windows, Linux Ctrl+Shift+P)) and select the prompt file from the Quick Pick.

You have multiple options to run a prompt file:

• Run the Chat: Run Prompt command from the Command Palette (⇧⌘P (Windows, Linux Ctrl+Shift+P)) and select a prompt file from the Quick Pick.

• In the Chat view, type / followed by the prompt file name in the chat input field.

  This option enables you to pass additional information in the chat input field. For example, /create-react-form or /create-react-form: formName=MyForm.

• Open the prompt file in the editor, and press the play button in the editor title area. You can choose to run the prompt in the current chat session or open a new chat session.

  This option is useful for quickly testing and iterating on your prompt files.

VS Code can sync your user prompt files across multiple devices by using Settings Sync.

To sync your user prompt files, enable Settings Sync for prompt and instruction files:

1. Make sure you have Settings Sync enabled.

2. Run Settings Sync: Configure from the Command Palette (⇧⌘P (Windows, Linux Ctrl+Shift+P)).

3. Select Prompts and Instructions from the list of settings to sync.

Enable or disable instructions and prompt files in VS Code with the chat.promptFiles setting.

To centrally enable or disable this setting within your organization with device management, check Centrally Manage VS Code Settings in the enterprise documentation.

• chat.promptFiles (Experimental): Enable reusable prompt and instructions files.

• github.copilot.chat.codeGeneration.useInstructionFiles: Controls whether code instructions from .github/copilot-instructions.md are added to Copilot requests.

• chat.instructionsFilesLocations (Experimental): A dictionary of folders where instructions files are located and a boolean indicating whether they are enabled. Relative paths are resolved from the root folder(s) of your workspace. Supports glob patterns for file paths. By default, instructions files are located in the .github/instructions folder of your workspace.

  "chat.instructionsFilesLocations": {
      "src/frontend/instructions": true,
      "src/backend/instructions": false
  }
  

• github.copilot.chat.codeGeneration.instructions (Experimental): set of instructions that will be added to Copilot requests that generate code.

• github.copilot.chat.testGeneration.instructions (Experimental): set of instructions that will be added to Copilot requests that generate tests.

• github.copilot.chat.reviewSelection.instructions (Preview): set of instructions that will be added to Copilot requests for reviewing the current editor selection.

• github.copilot.chat.commitMessageGeneration.instructions (Experimental): set of instructions that will be added to Copilot requests that generate commit messages.

• github.copilot.chat.pullRequestDescriptionGeneration.instructions (Experimental): set of instructions that will be added to Copilot requests that generate pull request titles and descriptions.

• chat.promptFiles (Experimental): Enable support for reusable prompt files and instruction files.

• chat.promptFilesLocations (Experimental): A dictionary of folders where prompt files are located and a boolean indicating whether they are enabled. Relative paths are resolved from the root folder(s) of your workspace. Supports glob patterns for file paths. By default, prompt files are located in the .github/prompts folder of your workspace.

  "chat.promptFilesLocations": {
      ".github/prompts": false,
      "setup/**/prompts": true
  }
  

• Create custom chat modes
• Get started with chat in VS Code
• Configure tools in chat

07/09/2025

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4