Browse GitHub Copilot Community (43)

junjieli introduces the Foundry Agent Canvas (public preview), a GitHub Copilot App extension that lets developers discover resources, scaffold and configure a Foundry hosted agent, test it locally with an embedded Agent Inspector, and deploy it to Foundry Agent Service using azd-driven workflows.

VimalVerma outlines Hypervelocity Engineering (HVE) as an operating model for building and continuously evolving Azure AI Landing Zones, with a focus on platform engineering, Infrastructure as Code, Policy as Code, and security-by-design so enterprise AI platforms can scale without losing governance.

Pamela Fox shows how to build an MCP server that returns more than plain text: image thumbnails as binary tool results and an interactive MCP app (a carousel) rendered inside VS Code, so GitHub Copilot can search, inspect, and present curated image results.

jisunchoi explains how to replace “multi-model chaos” with a governed AI gateway on Azure using Azure API Management, covering cost controls (token quotas and budget-based model downgrades), security hardening (managed identity + private endpoints), observability with Application Insights, and a Terraform-based deployment you can integrate with GitHub Copilot.

Dustin Ellis outlines practical ways to keep GitHub Copilot usage predictable under usage-based billing, focusing on token drivers like model choice, context size, and tool/agent usage. The post includes concrete prompting patterns, team guardrails, and lightweight policy ideas to reduce waste without losing the benefits of AI-assisted development.

kinfey explains why “token economics” has become a core architecture concern for agentic AI systems, using GitHub Copilot’s shift to usage-based billing as a concrete framing. The post breaks down practical engineering techniques—compression, caching, routing, and short-term memory—and shows how to evaluate cost, quality, and reliability together.

Lee Stott walks through a full “Multi‑Agent Dev Canvas” scenario for GitHub Copilot Canvas, showing how to decompose work, execute agent flows, validate with in-surface tests, inject failures, and evolve the design live (including GDPR/PII redaction) until the system meets its acceptance criteria.

Lee Stott explains what GitHub Copilot App Canvas is actually for: a development-time runtime where humans and AI agents can observe, steer, test, and evolve a running multi-agent system. The post walks through a real Canvas extension and the core building blocks needed to implement one.

Lee Stott explains the Model Context Protocol (MCP) and why it’s becoming a practical standard for connecting LLM apps to tools and data. The post highlights recent updates to Microsoft’s MCP for Beginners curriculum, including spec alignment, validated SDK samples, and a security-focused refresh with concrete fixes and audits.

Nikita Bajaj explains how Azure Migrate integrates with GitHub Copilot Modernize (public preview) to generate portfolio-level code insights across multiple applications and repositories, helping teams assess Azure readiness, review remediation guidance, and plan modernization work using a shared workflow between migration admins and developers.

Anavi Nahar rounds up Azure Databricks announcements and sessions from Databricks Data + AI Summit 2026, focusing on tighter interoperability with Microsoft’s data stack (OneLake, ADLS) and governed access via Unity Catalog, plus new integrations like the Excel add-in, SharePoint ingestion, and OneLake catalog federation.

kinfey breaks down a cost- and security-aware blueprint for running a multi-agent SDLC “tower” on AKS, using AI Runway for in-cluster model serving, Kata MicroVM isolation for each agent pod, and MCP so GitHub Copilot Chat can orchestrate tools while keeping token spend predictable.

Priyanka Nanda summarizes the Build 2026 updates for Azure Monitor, including new agent observability features, the Azure Copilot Observability agent, expanded OpenTelemetry/OTLP ingestion, and improvements to alerts, metrics querying, and SLI/SLO tracking across services like AKS and Application Insights.

DivSwa introduces Azure Logic Apps Automation (public preview), a new SaaS-style SKU for building and running workflow automations on Azure with built-in governance and production controls. The post highlights AI-assisted authoring, agent integration options (including Foundry agents and GitHub Copilot harnesses), and enterprise features like VNet/private endpoints, RBAC, and audit logging.

Mike Hulme introduces Microsoft’s “agentic modernization” approach, combining Azure Copilot migration agent and the GitHub Copilot modernization agent to help teams plan and execute large-scale application modernization, from estate discovery and dependency mapping through code transformation, PR-based execution, and governed rollout on Azure.

KayodePrince explains how to monitor AI coding agents by exporting OpenTelemetry (OTLP) signals and ingesting them into Azure Monitor, then using Application Insights agent views and Grafana dashboards to troubleshoot performance, understand usage, and track token-related cost signals.

Jason Pereira introduces two Azure Databricks public preview capabilities that connect Microsoft Copilot Studio and GitHub Copilot to Databricks: a workspace-wide Genie MCP endpoint for building workspace-aware agents, and Lakebase branching for debugging agent issues against real data without touching production.

TulikaC introduces a new Azure CLI switch for az webapp deploy that surfaces richer, more actionable diagnostics when Azure App Service for Linux deployments fail, including error codes, deployment context, suggested fixes, and a Copilot-ready prompt you can paste into GitHub Copilot for follow-up guidance.

jometzg shows how to build a GitHub Copilot agent usage dashboard by exporting VS Code Copilot telemetry via OpenTelemetry to an OTLP collector running on Azure Container Apps, sending it into Application Insights/Azure Monitor, and visualizing it in Azure Managed Grafana with IaC-friendly deployment and troubleshooting steps.

kinfey lays out a practical two-layer architecture for building and operating AI agents using Microsoft Agent Framework and Microsoft Foundry, with GitHub Copilot acting as a “coding agent” guided by versioned SKILL files. The post uses the ZavaShop workshop to show tools, MCP, workflows, evals, and deployment/ops guardrails across Python and .NET.

paggarwal introduces Engineering Squad, an open-source multi-agent framework that turns plain-text requirements into user stories, technical design, production code, and automated tests using Azure OpenAI and Foundry Local, with a self-correcting review loop and traceable run artifacts.

dbandaru explains how to connect Azure SRE Agent tools to the Azure MCP Server so developers can operate SRE Agents from MCP-compatible clients like GitHub Copilot CLI and VS Code Copilot. It covers setup, RBAC requirements, control-plane vs data-plane behavior, safety guardrails, and common troubleshooting steps.

nelsontam introduces the Microsoft Planetary Computer Pro MCP Tools VS Code extension, which integrates with GitHub Copilot to run geospatial workflows via natural-language prompts. It highlights STAC-based discovery, GeoCatalog management, and ingestion/monitoring features aimed at reducing the need for custom scripts and fragmented tooling.

Tsuyoshi Ushio shares how the Azure Functions team evolved its incident investigation approach from early AI-assisted RCA agents to GitHub Copilot-based coding agents, and then to cloud-hosted automation with Azure SRE Agent, including practical lessons on context, tools, and operational constraints.

Lee Stott announces Agents League, a week-long hackathon (part of AI Skills Fest) featuring live “AI coding battles” and project submissions across tracks using GitHub Copilot, Microsoft Foundry, and Copilot Studio, with a $55,000 prize pool and a Microsoft Reactor event series.

Karl Abbott shares a copy/paste prompt set for using GitHub Copilot CLI to provision Azure Linux VMs, deploy a Flask + PostgreSQL app behind Nginx with TLS, then add observability via an Ansible playbook that sets up Azure Monitor Agent, Log Analytics, and Managed Grafana.

Pablo Lopes explains why the first step in a .NET upgrade should be an assessment pass, not immediate code changes. Using the GitHub Copilot modernization agent as an example, he shows how an upfront report on projects, NuGet dependencies, and API behavior changes helps teams plan upgrades with fewer surprises.

bhramesh explains how to connect a VS Code Copilot agent to Azure DevOps using the Azure DevOps MCP server, outlining prerequisites, the high-level architecture, and what DevOps tasks you can run through MCP. The post also calls out security practices like trusted servers and least-privilege access.

kinfey introduces “AgenticOps” using the microsoft/AKS-Lab-GitHubCopilot workshop, showing how six scoped GitHub Copilot Custom Coding Agents plus the remote Copilot Coding Agent can author specs, code, tests, and deployments with explicit ownership and refusal rules, gated by evals and CI/CD.

kinfey explains why AI agents running model-generated code need stronger isolation than standard containers, then walks through deploying a GitHub Copilot SDK agent on AKS using Kata Containers (kata-vm-isolation) plus layered hardening like seccomp, NetworkPolicy egress allowlists, and deny-by-default tool permissions.

osmancokakoglu announces the winners of the AI Dev Days Hackathon and summarizes the projects and the Microsoft stack they used, including Azure AI Foundry, Azure OpenAI models, and the Microsoft Agent Framework, plus common Azure services and DevOps practices used to ship production-grade agentic apps.

SagarPatra explains how enterprise QA teams can use GitHub Copilot to reduce the mechanical overhead of writing and maintaining automated tests, while keeping trust through human review, governance, and intentional test design that supports reliable regression cycles.

shwetayadav explains how index-based Terraform for_each keys can trigger destructive disk churn on Azure, and shows a safer migration approach using stable keys plus terraform state mv, with a reusable GitHub Copilot skill to generate deterministic state-move commands.

mscagliola shows how to use GitHub Copilot skills for spec-driven development, turning a Medallion Architecture blog post into a repeatable repo that generates Terraform for Azure platform setup and Databricks bundle files for workloads, while enforcing strict placeholder/TODO rules to avoid invented environment values.

SagarPatra explains how their QA team used GitHub Copilot as a practical assistant for test design, automation scaffolding, and maintenance work, while keeping human review and responsible AI practices non-negotiable.

Steven Bucher announces the public preview of the Azure Resource Manager MCP Server, a remote MCP server that lets AI agents query and operate on Azure resources via Azure Resource Manager and Azure Resource Graph, including generating KQL queries from natural language and deploying ARM templates from within VS Code.

hcamposu introduces the Logic Apps Migration Agent, an open-source, AI-assisted approach for migrating BizTalk Server (and other integration platforms) to Azure Logic Apps Standard, with a structured workflow, human review checkpoints, and a code-first experience via VS Code and GitHub Copilot.

mohashaikh shows how to use GitHub Copilot Spaces plus a dedicated Markdown “engineering knowledge base” repo to make Copilot answer questions and generate code in line with your team’s standards, with optional in-repo instruction files and reusable prompt-file slash commands for consistent reviews.

gurkirat explains how GitHub Copilot can speed up Azure Landing Zone work by shifting engineers from writing Terraform and pipelines by hand to prompting for a structured draft and then reviewing it, with examples spanning management groups, networking, OIDC, GitHub Actions, and policy assignments.

sutandan explains spec-driven development as a more reliable alternative to the “prompt → retry → guess” loop when using AI coding tools, showing how a lightweight specification (inputs, outputs, constraints, edge cases) can make generated code more consistent for APIs and refactoring tasks.