awesome-copilot-agents

repository·main·Indexed 20 days ago

https://github.com/code-and-sorts/awesome-copilot-agents

A curated collection of instructions, prompts, skills, MCPs, and custom agent markdown files designed to enhance the GitHub Copilot AI experience. It provides repository-specific context for various languages, frameworks, and tools, including specialized agents for roles like Architect and Debugger, and guidelines for Infrastructure-as-Code (IaC) development.

Tokens
386K
Snippets
1.6K
Records
1.7K
Agent score
68%

What's inside awesome-copilot-agents

  1. Explore Azure Container Apps CLI subgroups

    main

    The az containerapp command is used to manage Azure Container Apps. The CLI is organized into several functional subgroups. Use these subgroups to target specific management tasks such as authentication, environment configuration, ingress settings, or job management.

    Key functional areas include:

    • Core Management: _root, create, delete, list, show, update, patch, up.
    • Networking & Connectivity: connection, connected-env, ingress, hostname, ssl.
    • Runtime & Scaling: replica, revision, session, sessionpool, resiliency.
    • Security & Identity: auth, identity, secret.
    • Application Logic: dapr, function, java, job.
    • Observability: logs, list-usages, debug.
    • Infrastructure: env, registry, add-on, arc.
  2. Use the Az CLI skill for Azure management

    main

    The az-cli skill is designed to help users manage Azure resources via the Azure CLI (az). It can be triggered when a user asks to create, configure, manage, deploy, or interact with Azure resources, or when they ask about Azure CLI command syntax and availability.

    Prerequisites:

    • The az-cli must be installed on the host system (Installation Guide).
    • The CLI must be authenticated via az login.
    # Ensure az-cli is installed and authenticated
    az login
  3. Manage Azure Red Hat OpenShift (ARO) clusters with az aro

    main

    The az aro command group provides a reference for managing Azure Red Hat OpenShift (ARO) clusters via the Azure CLI. Use these commands to perform lifecycle operations such as creating, deleting, updating, and inspecting clusters, as well as managing credentials and versions.

    # Create a cluster.
    az aro create
    
    # Delete a cluster.
    az aro delete
    
    # List clusters.
    az aro list
    
    # Get the details of a cluster.
    az aro show
    
    # Update a cluster.
    az aro update
  4. Manage Network Fabric resources with az networkfabric

    main

    The az networkfabric CLI command group is used to manage various components of a Network Fabric infrastructure, including controllers, devices, networks, and security policies. Most resource types support standard CRUD operations (create, delete, list, show, update) and a wait command to pause execution until a specific condition is met.

    # Example: List all Network Fabrics
    az networkfabric fabric list
    
    # Example: Show details of a specific Network Fabric
    az networkfabric fabric show
  5. Manage Dev Center administration with `az devcenter admin`

    main

    The az devcenter admin command group is used for high-level administrative tasks within a Dev Center, such as managing catalogs, projects, network connections, and dev box definitions. These commands are typically used for infrastructure setup and governance rather than day-to-day developer workflows.

    # Example: Create a new dev center
    az devcenter admin devcenter create
    
    # Example: List all dev centers in a resource group
    az devcenter admin devcenter list
  6. Manage Dev Box developer workflows with `az devcenter dev`

    main

    The az devcenter dev command group is designed for end-user (developer) interactions with Dev Center resources like Dev Boxes and Environments.

    Dev Box Management

    • az devcenter dev dev-box create: Create a new dev box.
    • az devcenter dev dev-box start / stop: Start or stop a dev box.
    • az devcenter dev dev-box restart: Restart a dev box.
    • az devcenter dev dev-box delete: Delete a dev box.
    • az devcenter dev dev-box show: Get dev box details.
    • az devcenter dev dev-box list: List dev boxes (for a user, project, or dev center).
    • az devcenter dev dev-box repair: Attempt automated repair steps (may cause restart).
    • az devcenter dev dev-box capture-snapshot: Capture a manual snapshot.
    • az devcenter dev dev-box restore-snapshot: Restore a dev box to a snapshot.
    • az devcenter dev dev-box set-active-hours: Set user-specific active hours.

    Environment Management

    • az devcenter dev environment create: Create an environment.
    • az devcenter dev environment deploy: Update/deploy an environment.
    • az devcenter dev environment list: List environments.
    • az devcenter dev environment show: Get environment details.
    • az devcenter dev environment delete: Delete an environment.
    • az devcenter dev environment show-outputs: Get outputs from the environment.
    az devcenter dev dev-box start
    az devcenter dev dev-box stop
  7. Use the azure-prices skill for Azure cost lookups

    main

    The azure-prices skill allows you to fetch and compare live Azure service pricing using the Azure Retail Prices API. It is designed to answer questions about Azure costs, rates, or comparisons across regions and services.

    Requirements:

    • Node.js must be installed.
    • No Azure credentials are required as it uses the public Azure Retail Prices API.

    Execution Rule: Always use the bundled npm scripts for price lookups. DO NOT call the Azure Retail Prices API directly; you must use the provided scripts to interface with the API.

  8. Manage Azure Container Instances with az container

    main

    The az container command group is used to manage Azure Container Instances (ACI) and container groups. It allows you to create, delete, start, stop, and inspect container groups, as well as execute commands within running containers.

    # Example of common container management commands
    az container create --resource-group myResourceGroup --name myContainerGroup --image mcr.microsoft.com/azuredocs/aci-helloworld
    az container list --resource-group myResourceGroup
    az container show --name myContainerGroup --resource-group myResourceGroup
  9. Understand the purpose of Copilot Agents

    main

    Copilot Agents are used to enhance the GitHub Copilot experience by providing contextual details about your repository. By using customized instructions, prompts, agent skills, MCPs (Model Context Protocol), and custom agents, you can guide Copilot on:

    • Team workflows
    • Project-specific tools
    • Coding styles
    • Frameworks used
    • Project-specific rules

    For implementation details on how to customize GitHub Copilot in VS Code, refer to the VS Code documentation.

  10. Project Architecture and File Structure for Node.js TypeScript Express APIs

    main

    This project follows a modular, layered architecture (MVC/Clean Architecture) to ensure a clear separation of concerns. When creating or updating files, follow this directory structure:

    • src/routes/: Domain-specific route definitions (e.g., user.routes.ts).
    • src/controllers/: Request handling and orchestration (e.g., user.controller.ts).
    • src/services/: Business logic implementation (e.g., user.service.ts).
    • src/repositories/: Data access layer (e.g., user.repository.ts).
    • src/schemas/: Zod validation schemas (e.g., user.schema.ts).
    • src/middleware/: Error handling and authentication (e.g., error.middleware.ts).
    • src/utils/, src/config/, src/types/: Supporting utilities, configuration, and type definitions.
    • tests/: Contains unit/ and integration/ test suites.
    src/
      routes/
        user.routes.ts
        product.routes.ts
      controllers/
        user.controller.ts
      services/
        user.service.ts
      repositories/
        user.repository.ts
      schemas/
        user.schema.ts
      middleware/
        error.middleware.ts
        auth.middleware.ts
      utils/
      config/
      types/
    tests/
      unit/
      integration/
  11. Swift architectural and implementation patterns

    main

    To ensure scalable and maintainable Swift code, follow these patterns:

    • UI Architecture: Use MVVM for SwiftUI-based interfaces.
    • State Management: Use SwiftUI property wrappers like @State, @ObservedObject, and @EnvironmentObject correctly.
    • Concurrency/Reactivity: Leverage Combine or async/await for asynchronous logic.
    • Dependency Management: Use dependency injection via initializers or protocols.
    • Componentization: Break down views into small, reusable components.
    • State Modeling: Use enums with associated values to manage screen or view states.
    • Data Handling: Use Codable for JSON encoding and decoding.

    Patterns to Avoid

    • Logic Placement: Do not put business logic directly inside Views.
    • Tight Coupling: Avoid mixing UIKit and SwiftUI unnecessarily.
    • Complexity: Avoid deeply nested views or view models; break them into modules.
    • Encapsulation Breaches: Do not expose internal state directly; use access control (private, internal, public).
    • Hardcoding: Avoid hardcoded strings or magic numbers; use constants or localization.
    • Unsafe Unwrapping: Avoid force unwraps (!).