Why GitHub Copilot custom instructions matter

I have been using GitHub Copilot for quite some time now in my IDE, its my daily driver – hopefully you have been doing similar. Have you ever had that moment where GitHub Copilot suggests code and you think, “Hmm, close… but not quite”? Like it almost gets your style, but then throws in a wildcard naming convention or forgets your team’s ways of working? That’s where custom instructions in GitHub Copilot come in to play and in this blog post I will cover this.

Why Custom Instructions Matter

Let’s be honest, GitHub Copilot out of the box is already impressive. But add custom instructions, and suddenly it’s like Copilot’s been reading your mind (or at least your team’s Slack channel).

Why does this matter right now? Because as AI tools like Copilot are smarter than ever – hello, Agent Mode – the need to make them your tools, not just a tool, is more important than ever.

Here’s why this small feature packs a big punch and five reasons to why you should be using it:

1. Personalisation:  Ever wish Copilot would just write code your way? Custom instructions let you set the tone, style, and even the quirks you love (or tolerate) in your codebase
2. Team Alignment: Ensure everyone on the team that makes changes to the repository adheres to the same guidelines without constant reminders. Every team has its quirks – naming conventions, file structures, forbidden patterns. Custom instructions help reinforce those norms without the usual Slack reminders.
3. Increases Efficiency: Less back-and-forth fixing style issues means more time actually building things. Who doesn’t want that?
4. Consistency: You know when you inherit code from someone and wonder, “What were they thinking?” With shared instructions, Copilot helps steer everyone toward the same direction.
5. Enhances Context: By giving Copilot more background, it starts suggesting stuff that just fits. It’s like pair programming with someone who’s already read your project’s README… twice.

What can you include in Custom Instructions?

Think of custom instructions as a way to communicate your expectations to Copilot. Here are a few examples to what I use Custom Instructions for:

• Natural Language Prompts: Simple phrases like “Always use camelCase for variables” or “Include comments only when you feel relevant and keep them concise.”
• Teams Coding Standards: Referencing specific rules and ways of working from my teams coding standards
• Guardrails: Defining boundaries, such as avoiding certain libraries and adhering to specific security protocols
• Documentation Guidelines: Ensuring all code generated includes proper documentation

For instance, in one of my recent projects, I added an instruction to always include tests with generated functions. The result? A smoother workflow and fewer last-minute scrambles to add tests before deployment.

Think of custom instructions as your inner coding thoughts – the stuff you wish Copilot just “got.” Things like:

• “Always use async/await in API calls.”
• “Use camelCase for variables in this Python repo.”
• “Follow the pattern from example-service when creating new endpoints.”

How To Get Started with Custom Instructions

Its very straight-forward to getting started:

1. Create an Instruction File:
   In the root of your repository, create a .github/copilot-instructions.md file. Add your instructions in plain Markdown format.
2. Create a sample set of instructions, below is an example of custom instructions for a Terraform related repository

# Terraform Coding Guidelines

## Code Style & Structure
- Always use [Terraform v1.9+] features where possible.
- Use consistent indentation (2 spaces) for readability.
- Group related resources logically (e.g., networking, compute, storage).
- Keep resource blocks short and well-organised—avoid large, complex blocks.

## Module Usage
- Prefer reusable modules over repeating code.
- Use standard module structure: `main.tf`, `variables.tf`, `outputs.tf`, `README.md`.
- For shared modules, source them from the approved GitHub org or Terraform Registry.

## Variables & Outputs
- All variables must have descriptions and types defined.
- Avoid hardcoding values—use variables or locals.
- Outputs should be meaningful and named consistently for reuse in parent modules.

##  Security & Secrets
- Never hardcode secrets or credentials.
- Use environment variables or secure backends like Azure Key Vault, AWS Secrets Manager, or Vault.
- Sensitive outputs should be marked with `sensitive = true`.

## Validation & Testing
- Include `terraform validate` and `terraform fmt -check` in CI.
- Use `pre-commit` hooks to enforce formatting and checks before merge.
- Run `terraform plan` with a named workspace in all pipelines.

## Naming & Tags
- Use consistent resource naming with project, environment, and region prefixes (e.g., `app-dev-uks-vm1`).
- All resources must have tags for `Name`, `Environment`, and `Owner`.

## Comments & Docs
- Add comments for complex resources or unusual patterns.
- Include a README in each module with usage examples and input/output documentation.

Add More Instructions as Needed

You can also create additional instructions to be referenced in a specific repostiory using github.copilot.chat.codeGeneration.instructions – I store these in .vscode/settings.json of my GitHub repository.

Example usage:

Notice both the ability to use additional file references and also text?

{
    "github.copilot.chat.codeGeneration.instructions": [
      {
        "file": “./terraform-standards.md"
      },
{
	“text”: “In Terraform, always avoid hardcoding values - use variables or locals”
}
    ]
  }

Wrapping up

If you haven’t tried custom instructions yet, now is the time. With GitHub rolling out features like Agent Mode (which makes Copilot feel more like an actual coding partner), the possibilities are expanding faster than ever.

Custom instructions in Copilot are a subtle but powerful way to inject your voice, your standards, and your team’s style into the AI coding experience. It’s not about making Copilot do everything – it’s about making it understand you better.

Here are some additional links I recommend you checking out: