Shared Workflows with Copilot

The real power of Copilot for teams emerges when you embed AI into your shared development workflows. This lesson covers how to establish team coding standards that Copilot reinforces, create shared prompt templates, automate PR reviews, and integrate Copilot with your CI/CD pipeline through GitHub Actions.

Enforcing Team Coding Standards with Copilot

Every engineering team has coding standards, but enforcing them consistently has always been challenging. Developers forget rules, linters catch only syntax-level issues, and code reviews become tedious when reviewers repeatedly flag the same style violations. Copilot changes this dynamic by suggesting code that already follows your team's conventions.

The key to making this work is providing Copilot with clear context about your standards. There are several approaches, each increasing in effectiveness:

• Repository-level instructions: Add a .github/copilot-instructions.md file to each repository with project-specific coding guidelines. Copilot reads this file and adjusts its suggestions accordingly.
• Organization-level instructions: For Enterprise plans, set org-wide instructions that apply to all repositories. This ensures consistency across your entire codebase.
• Knowledge bases: Include your style guide and architecture documentation in a knowledge base so developers can ask Copilot Chat about conventions.
• Code examples: Copilot learns from the patterns in your existing code. Well-structured existing code naturally produces better suggestions.

Creating Shared Prompt Templates

Shared prompt templates standardize how your team interacts with Copilot Chat. Instead of each developer crafting their own prompts for common tasks, your team maintains a library of proven templates that produce consistent, high-quality outputs.

Effective prompt templates include clear instructions, specify the desired output format, and provide relevant context. Here are categories of templates that teams commonly maintain:

Automating Pull Request Reviews with Copilot

Copilot can automatically generate PR summaries, suggest review comments, and flag potential issues before human reviewers even look at the code. This accelerates the review process and ensures that common issues are caught early.

Copilot's PR features include:

• Automatic PR summaries: When a PR is opened, Copilot generates a plain-language summary of all changes, organized by file and component.
• Review suggestions: Copilot analyzes the diff and suggests improvements, flags potential bugs, and identifies missing test coverage.
• Change categorization: Copilot labels changes as bug fixes, features, refactoring, or documentation updates, making it easier for reviewers to prioritize their attention.
• Linked issue detection: Copilot identifies which issues or tickets are addressed by the PR based on the code changes, not just commit message references.

To enable these features, navigate to your organization's Copilot settings and enable "Copilot pull request summaries" under the features section. Once enabled, every PR in your organization automatically receives an AI-generated summary.

CI/CD Integration with GitHub Actions

GitHub Actions provides the automation backbone for integrating Copilot into your continuous integration and delivery pipeline. You can create workflows that leverage Copilot's capabilities at various stages of your development process.

# .github/workflows/copilot-pr-review.yml
name: Copilot-Assisted PR Review

on:
  pull_request:
    types: [opened, synchronize]

permissions:
  contents: read
  pull-requests: write

jobs:
  copilot-review:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
        uses: actions/checkout@v4
        with:
          fetch-depth: 0

      - name: Generate PR Summary
        uses: github/copilot-pr-summary@v1
        with:
          github-token: ${{ secrets.GITHUB_TOKEN }}
          summary-style: detailed
          include-file-tree: true

      - name: Run Copilot Code Review
        uses: github/copilot-code-review@v1
        with:
          github-token: ${{ secrets.GITHUB_TOKEN }}
          review-scope: changed-files
          severity-threshold: medium
          categories:
            - security
            - performance
            - best-practices
            - error-handling

      - name: Check Test Coverage
        uses: github/copilot-test-coverage@v1
        with:
          github-token: ${{ secrets.GITHUB_TOKEN }}
          suggest-missing-tests: true
          min-coverage-threshold: 80

      - name: Post Review Summary
        if: always()
        uses: github/copilot-review-summary@v1
        with:
          github-token: ${{ secrets.GITHUB_TOKEN }}
          post-as-comment: true
          include-metrics: true

This workflow runs automatically on every PR, generating a summary, performing a code review, checking test coverage, and posting results as PR comments. Human reviewers can then focus on architectural decisions and business logic while Copilot handles the routine checks.

Repository-Level Copilot Instructions

The .github/copilot-instructions.md file is a powerful way to customize Copilot's behavior for a specific repository. This file is automatically included in Copilot's context for all suggestions and chat interactions within that repository.

# Copilot Instructions for payment-service

## Project Overview
This is our payment processing microservice built with Go 1.22.
It handles all payment transactions, refunds, and subscription management.

## Coding Standards
- Use structured logging with `slog` (never `fmt.Println` or `log`)
- All database queries must use parameterized statements (no string concatenation)
- Error handling: always wrap errors with `fmt.Errorf("context: %w", err)`
- Use context.Context as the first parameter for all public functions
- HTTP handlers must validate input before processing

## Architecture Patterns
- Repository pattern for database access (see `internal/repository/`)
- Service layer for business logic (see `internal/service/`)
- Handler layer for HTTP concerns only (see `internal/handler/`)
- Never call repositories directly from handlers

## Testing Standards
- Table-driven tests for all business logic
- Use testcontainers for integration tests
- Mock external services, never real network calls in unit tests
- Minimum 80% coverage for new code

## Security Requirements
- Never log PII (card numbers, SSNs, etc.)
- All monetary values use `decimal.Decimal`, never float64
- Rate limit all public endpoints
- Validate webhook signatures before processing

When this file is present, Copilot adjusts its suggestions to follow these guidelines. For example, it will suggest slog.Info() instead of fmt.Println(), use parameterized queries instead of string concatenation, and follow the repository pattern for database access.

Common Workflow Automation Patterns

Beyond PR reviews, teams use Copilot with GitHub Actions for a variety of automation patterns that streamline the development lifecycle.