vab-awesome-copilot

A curated collection of AI customization artifacts for GitHub Copilot and other AI coding agents, optimized for .NET/C# development workflows.

Overview

This repository bundles reusable agents, chat modes, instructions, and prompts that enhance AI-assisted development. Whether you're architecting Azure solutions, upgrading .NET projects, or maintaining code quality standards, these artifacts provide specialized AI personas and workflows tailored to your needs.

Key Benefits:

• Standards-Driven Development: Enforce coding standards automatically through instruction files
• Specialized Expertise: Access domain-specific agents for complex tasks (Azure Functions migration, REST API design, etc.)
• Context-Aware Workflows: Switch between chat modes optimized for planning, architecture, or implementation
• Composable Patterns: Mix and match prompts for common development tasks
• Production-Ready Focus: Emphasizes security, observability, and cloud-native patterns

What's Inside

🤖 Agents (3)

Specialized AI personas for complex, multi-step tasks:

• CSharpExpert - .NET development expert covering architecture, testing, and async patterns
• FunctionTechnicalUpgrader - Automated Azure Functions migration to .NET 8+ isolated worker model
• RestExpert - REST API design and implementation specialist

💬 Chat Modes (7)

Context-specific development workflows:

• azure-principal-architect - Azure Well-Architected Framework guidance with Microsoft docs integration
• backend-engineer - Backend API development patterns
• plan - Strategic planning before implementation (think-first approach)
• specification - Generate structured spec documents with standardized templates
• gpt-5-beast-mode - Advanced problem-solving mode
• simple-app-idea-generator - Rapid application ideation

📋 Instructions (2)

Language/framework-specific coding guidelines:

• csharp.instructions.md - C# 13 development standards (applies to **/*.cs)
• instructions.instructions.md - Meta-guide for creating instruction files

🎯 Prompts (8)

Reusable templates for specific tasks:

• review-and-refactor - Code review against project standards
• prompt-builder - Interactive guide for creating new prompts
• breakdown-feature-implementation - Detailed implementation plans with diagrams
• csharp-async, csharp-xunit - C# specific development patterns
• documentation-writer - Diátaxis framework documentation
• dotnet-best-practices - .NET code review

Getting Started

Prerequisites

• Visual Studio Code
• GitHub Copilot extension
• GitHub Copilot Chat extension

Using Artifacts in GitHub Copilot

Instructions apply automatically when editing matching files:

# csharp.instructions.md applies to all .cs files
applyTo: '**/*.cs'

Agents are invoked through Copilot Chat:

@workspace /agent CSharpExpert help me design a repository pattern

Chat Modes provide context-specific assistance:

Use azure-principal-architect mode to design a multi-region deployment

Prompts are referenced in conversations:

Use the review-and-refactor prompt on this service class

Quick Examples

Upgrade an Azure Functions project:

@workspace /agent FunctionTechnicalUpgrader analyze this project and create an upgrade plan to .NET 8 isolated worker model

Generate a specification document:

Switch to specification mode and create a spec for the user authentication feature

Review code against standards:

Use the review-and-refactor prompt to check this file against .github/instructions

Artifact Types Explained

Instructions (.instructions.md)

When to use: Apply consistent coding standards automatically to file patterns.

How it works: Place in .github/instructions/ with frontmatter specifying file patterns:

---
description: 'C# development guidelines'
applyTo: '**/*.cs'
---

Key C# conventions enforced:

• Latest C# 13 features, file-scoped namespaces
• Null checks: ArgumentNullException.ThrowIfNull(x)
• Async naming: all async methods end with Async
• Behavioral test naming: WhenCatMeowsThenCatDoorOpens

Agents (.agent.md)

When to use: Complex, multi-step tasks requiring specialized domain expertise.

How to invoke: Reference by name in Copilot Chat:

@workspace /agent [AgentName] [your request]

Example use cases:

• Migrating Azure Functions projects to new runtime versions
• Architecting .NET applications with SOLID principles
• Designing RESTful APIs following best practices

Chat Modes (.chatmode.md)

When to use: Context-specific workflows with tailored tool access.

Key patterns:

• plan mode: Uses only read/analysis tools to encourage strategic thinking before coding
• azure-principal-architect mode: Searches Microsoft docs before recommendations, asks for SLA/RTO/RPO/budget clarifications
• specification mode: Generates specs as /spec/spec-[purpose]-[name].md with acceptance criteria

How to switch: Mention the mode in your conversation:

Switch to plan mode and help me understand this codebase

Prompts (.prompt.md)

When to use: Reusable templates for specific, repeatable tasks.

How to reference: Mention the prompt name in conversation:

Apply the dotnet-best-practices prompt to review this API controller

Composability: Prompts can reference instructions and other prompts, creating powerful workflows.

Featured Artifacts

🔧 FunctionTechnicalUpgrader Agent

Use case: Automate Azure Functions migration to .NET 8+ with isolated worker model.

What it does:

• Detects current execution model (in-process vs isolated)
• Generates exact project file changes, Program.cs bootstrap
• Converts bindings to isolated worker equivalents
• Provides local testing checklist and Azure app settings
• References Microsoft Learn docs for all decisions

Why it's valuable: In-process support ends November 10, 2026. This agent handles the complex migration automatically with production-ready patterns.

🏗️ Azure Principal Architect Chat Mode

Use case: Design Azure solutions following Well-Architected Framework principles.

What it does:

• Searches microsoft.docs.mcp and azure_query_learn before recommendations
• Evaluates all 5 WAF pillars: Security, Reliability, Performance, Cost, Operations
• Asks clarifying questions for critical requirements (SLA, compliance, budget)
• Provides specific Azure service configurations with documented best practices

Why it's valuable: Ensures architectural decisions are backed by official Microsoft guidance and considers all trade-offs.

📝 Review and Refactor Prompt

Use case: Enforce coding standards across your codebase.

What it does:

1. Reads all .github/instructions/*.md and .github/copilot-instructions.md
2. Reviews code for compliance
3. Applies refactorings while maintaining tests
4. Keeps existing file structure intact

Why it's valuable: Automates code review against project-specific standards, not just generic linting rules.

🎯 Plan Chat Mode

Use case: Think strategically before implementing features.

What it does:

• Restricts to read/analysis tools only (codebase, search, usages)
• Encourages exploration and understanding before changes
• Helps identify constraints, dependencies, and integration points
• Develops comprehensive implementation strategies

Why it's valuable: Prevents premature implementation by fostering thoughtful analysis and planning.

Contributing

We welcome contributions! Here's how to add new artifacts:

File Naming Conventions

• Use lowercase with hyphens: react-best-practices.instructions.md
• Be descriptive and specific
• Follow established patterns in each directory

Frontmatter Requirements

Instructions:

---
description: 'Brief description (1-500 chars)'
applyTo: 'glob pattern (e.g., **/*.cs)'
---

Agents:

---
name: Agent Name
description: Brief description
# version: YYYY-MM-DDa (optional)
---

Chat Modes:

---
description: 'Mode description'
tools: ['tool1', 'tool2', ...]
---

Prompts:

---
mode: 'agent|ask|edit'
description: 'Prompt description'
tools: ['tool1', 'tool2', ...]  # Optional
---

Content Guidelines

1. Be Specific: Include concrete examples from actual code, not abstract advice
2. Use Imperative Mood: "Use", "Implement", "Avoid" (not "should" or "might")
3. Explain Why: When it adds value (e.g., "in-process support ends Nov 10, 2026")
4. Show Examples: Include both good and bad examples with clear labels
5. Stay Actionable: Focus on discoverable patterns, not aspirational practices

Testing Before Submission

1. Test with GitHub Copilot to verify frontmatter is recognized
2. Ensure examples are accurate and compile/run successfully
3. Verify glob patterns match intended files
4. Check for consistency with existing artifacts in the same category

Creating New Instruction Files

Use the prompt-builder.prompt.md or follow the instructions.instructions.md template:

1. Include frontmatter with description and applyTo
2. Structure: General Instructions → Best Practices → Code Standards → Common Patterns → Examples
3. Save to .github/instructions/[name].instructions.md

Creating New Specification Documents

Use the specification.chatmode.md:

1. File naming: spec-[purpose]-[name].md (purpose: schema, tool, data, infrastructure, process, architecture, design)
2. Include frontmatter: title, version, date_created, owner, tags
3. Required sections: Purpose & Scope, Requirements (REQ-001), Acceptance Criteria (AC-001 with Given-When-Then), Test Automation Strategy

Integration & Compatibility

GitHub Copilot

Instructions apply automatically via applyTo patterns when editing files. Agents, chat modes, and prompts are accessible through Copilot Chat.

VS Code

All artifacts are designed for seamless integration with VS Code's Copilot extensions. Custom modes and prompts appear in the Copilot Chat interface.

Azure Tools

The azure-principal-architect mode integrates with:

• microsoft.docs.mcp - Microsoft documentation search
• azure_query_learn - Azure-specific guidance
• Azure-specific best practice tools

External MCPs

Modes can reference external Model Context Protocol servers:

• mcp-atlassian - Project management integration
• browser-automation - Web-based research
• Custom MCP servers for specialized workflows

Philosophy & Principles

1. Standards-Driven: All code generation follows .instructions.md files
2. Composable: Prompts and modes reference each other and instructions
3. .NET-Focused: Primary expertise in C# 13, .NET 8+, Azure Functions, ASP.NET Core
4. Production-Ready: Emphasis on security, observability, cloud-native patterns, test coverage
5. Documentation-Backed: Azure modes cite Microsoft Learn; agents reference official docs
6. Think-First: plan.chatmode.md encourages analysis before implementation

Related Resources

• GitHub Copilot Documentation
• Custom Instructions Guide
• Diátaxis Documentation Framework
• Azure Well-Architected Framework
• Microsoft Learn - .NET

License

This repository is provided as-is for use with GitHub Copilot and compatible AI coding assistants.

---

Maintained by: VAB-development
Questions or suggestions? Open an issue or contribute a pull request!