awesome-copilot

Enables creation of domain-specific agents through a markdown-based agent definition format (.agent.md) that integrates with GitHub Copilot via MCP (Model Context Protocol) servers. Agents are installed and activated through a registry system that maps agent metadata (name, description, capabilities) to executable MCP server bindings, allowing Copilot to invoke specialized behavior for specific technologies (e.g., Terraform, ARM migration). The architecture supports both built-in agents and external plugin-based agents through a plugin manifest system.

Provides a modular skill system where discrete capabilities (e.g., 'sponsor finder', 'fabric lakehouse integration') are packaged as reusable units with SKILL.md format, including embedded prompts, examples, and asset bundles (code snippets, configuration templates). Skills are discoverable through a skills registry and can be composed into agents or used standalone within Copilot. The SKILL.md format enforces structured metadata (name, description, use cases, examples) and supports asset bundling for context-aware code generation.

Provides automated documentation generation from content metadata and a learning hub with cookbook examples demonstrating how to use agents, skills, and workflows. The documentation pipeline generates API documentation, usage guides, and examples from content files, while the learning hub curates best practices and real-world examples. The system supports multiple documentation formats (Markdown, HTML) and integrates with a website (Astro-based) for publishing.

Provides automated contributor recognition and attribution by extracting Git history, tracking contributions across content types, and generating contributor reports. The system maintains a contributor database (.all-contributorsrc) with attribution metadata and generates contributor recognition in documentation and marketplace. Metrics track contribution volume, content quality, and community impact.

Provides a modern, searchable website (Astro-based) for discovering and exploring agents, skills, instructions, workflows, and plugins. The website includes full-text search powered by Pagefind, filtering by category/language/technology, and a responsive UI for browsing content. The platform integrates with the marketplace discovery system and learning hub to provide a unified discovery experience.

Provides a structured contribution workflow for submitting new agents, skills, instructions, and workflows through pull requests with automated quality checks, community review, and merge automation. The workflow includes contribution guidelines, templates for each content type, automated validation, and a review process that ensures quality before merging. Merge automation handles contributor recognition, documentation updates, and marketplace indexing.

Allows injection of custom instructions into Copilot's behavior through .instructions.md files with YAML frontmatter, supporting language-specific instructions (Python, JavaScript, Go, etc.) and context management strategies. Instructions are applied globally or scoped to specific file types/projects, enabling teams to enforce coding standards, architectural patterns (OOP design patterns), and domain-specific conventions without modifying Copilot's core behavior. The instruction system integrates with Copilot's prompt context management to prioritize instructions based on file type and project configuration.

Provides a structured prompt file system (.prompt.md format) with quality standards and task-specific templates that enable composition of reusable prompt fragments for common Copilot tasks (code review, refactoring, documentation generation). Prompts are indexed by task type and can be combined to create complex multi-step workflows. The system enforces prompt quality standards (clarity, specificity, examples) and includes a validation pipeline to ensure prompts meet organizational guidelines before distribution.

Enables definition of multi-step agentic workflows using a declarative workflow definition format that supports DAG (directed acyclic graph) task planning, phase-based execution, and event-driven hooks. Workflows coordinate multiple agents and skills to accomplish complex tasks (e.g., infrastructure provisioning, code migration) with explicit task dependencies, error handling, and security boundaries. The architecture supports the Ralph Loop pattern (Reasoning → Action → Learning → Feedback) for iterative task execution and includes hooks for event-driven automation (pre/post-task, on-error).

Provides a hook system for event-driven automation that triggers scripts (bash, Python, JavaScript) on workflow events (pre-task, post-task, on-error, on-success). Hooks enable integration with external systems (CI/CD, monitoring, notifications) and allow teams to extend workflow behavior without modifying core workflow definitions. The architecture supports hook chaining (sequential execution) and conditional execution based on task results.

Provides a plugin architecture that enables external developers to create and distribute plugins (agents, skills, instructions, workflows) through a centralized marketplace. Plugins are defined via plugin.json manifest files with metadata (name, description, version, dependencies) and can be installed into awesome-copilot via a plugin registry. The system supports plugin versioning, dependency resolution, and external plugin integration without requiring changes to core awesome-copilot code.

Implements advanced multi-agent orchestration using the GEM Team pattern (Group, Expand, Merge) combined with phase-based workflow execution. Multiple specialized agents (e.g., architect, implementer, reviewer) work in coordinated phases, with explicit handoff points and context sharing between agents. The architecture supports task decomposition into agent-specific responsibilities and merges results from parallel agent execution, enabling complex collaborative workflows.

Provides a searchable marketplace for discovering agents, skills, instructions, workflows, and plugins through a metadata-driven indexing system. The marketplace includes full-text search, filtering by category/language/technology, and ranking by popularity/recency. Metadata is extracted from content files (YAML frontmatter, README files) and indexed by a build pipeline, enabling fast discovery without requiring manual curation.

Implements a comprehensive build pipeline that validates content quality, extracts metadata, generates marketplace indexes, and enforces quality gates before publishing. The pipeline includes frontmatter validation, documentation generation, marketplace generation, and contributor recognition. Quality gates ensure content meets standards (metadata completeness, example coverage, clarity) before distribution, preventing low-quality contributions from reaching users.