Building with Azure Skills | All things Azure

Part 3 of the Azure Skills Plugin series

Previously: How to Install the Azure Plugin

You’ve installed the Azure Skills Plugin. The Azure MCP server is running.

You have a huge collection of tools and skills at your disposal.

So, now what do you actually say to it?

This post is a prompt cookbook. Every example below is a real prompt you can type into Copilot Chat (or Copilot CLI, or Claude Code) with the Azure Plugin installed. Each one triggers a specific skill and produces a concrete, actionable result – not generic advice.

A note on scope: Azure is huge, and the examples below reflect that – there are a lot of them. This list is by no means comprehensive. It’s meant to give you ideas and show the range of what’s possible, not to catalog every skill or scenario. If you think of a prompt that isn’t listed here, try it anyway – you’ll probably be surprised.

Don’t have the plugin yet? Install it first: aka.ms/azure-plugin

How to Read This Post

Each section covers a category of Azure work. Within each category you’ll find:

The skill that activates
Example prompts you can copy and use immediately
What happens when you run it – what the skill does behind the scenes

You don’t need to memorize skill names. Just type naturally. The plugin matches your intent to the right skill automatically.

🏗️ Creating and Deploying Apps

These are the prompts you’ll use most often. The three core workflow skills – azure-prepare, azure-validate, and azure-deploy – handle the full lifecycle from source code to production.

You usually don’t need to call these individually. Agents like Copilot will automatically string together prepare → validate → deploy when you ask it to deploy your app. You just describe what you want, and the agent orchestrates the right sequence of skills for you. The individual prompts below are useful for when you want fine-grained control over a single step.

Starting a New Project

Skill: azure-prepare

"I have a Python FastAPI app. Prepare it for deployment to Azure."

"Create the infrastructure for a Node.js Express API on Azure Container Apps"

"Set up this React frontend as an Azure Static Web App with a Python API backend"

"Generate Terraform for a containerized Go microservice on Azure"

"I want to deploy this Django app to Azure App Service - generate the Bicep and Dockerfile"

"Prepare this project for Azure using Terraform instead of Bicep"

What happens: Copilot analyzes your project, recommends Azure services, and generates infrastructure code (Bicep or Terraform), a Dockerfile, and an azure.yaml manifest. You get a deploy-ready project without writing any of that by hand.

Validating Before Deploy

Skill: azure-validate

"Validate my Azure configuration before I deploy"

"Check if this project is ready for deployment to Azure"

"Run preflight checks on my Bicep files"

"Verify my Azure Functions configuration is correct"

What happens: Copilot checks your infrastructure code for errors, validates your azure.yaml, verifies Azure CLI authentication, checks permissions, and reports anything that would cause a deployment to fail. Think of it as a dry run.

Deploying

Skill: azure-deploy

"Deploy this project to Azure"

"Run azd up"

"Push this to production on Azure"

"Ship it"

What happens: Copilot orchestrates the deployment via azd, provisions infrastructure, builds and pushes container images, deploys your code, and returns the live URL. It follows the deployment plan created by azure-prepare.

The One-Liner

You don’t have to run these skills individually. A single prompt can trigger the full pipeline:

"Create and deploy this Python Flask API to Azure Container Apps"

Copilot will chain azure-prepare → azure-validate → azure-deploy automatically.

💰 Cost and Resource Management

Finding Waste

Skill: azure-cost-optimization

"Analyze my Azure spending and find savings"

"What orphaned resources do I have in my subscription?"

"Are any of my VMs oversized?"

"Show me my top 10 most expensive resources this month"

"How much could I save with reserved instances?"

"Find unused public IPs and unattached disks"

What happens: Copilot scans your subscription using Azure Cost Management APIs and utilization metrics. It identifies orphaned resources, oversized VMs, wrong storage tiers, and idle dev environments – then estimates the savings for each recommendation.

Checking Quotas

Skill: azure-quotas

"How many vCPUs do I have available in East US?"

"Check my quota for GPU VMs in West US 2"

"Will I hit any limits if I deploy 10 D4s_v5 VMs?"

"Show my current usage vs. limits for compute in all regions"

What happens: Copilot queries Azure quota APIs to show your current usage, limits, and remaining capacity. Useful before a big deployment or when you hit a mysterious provisioning failure.

🔍 Finding and Exploring Resources

Listing What You Have

Skill: azure-resource-lookup

"List all my Azure resource groups"

"What container apps do I have running?"

"Show me all storage accounts in the production resource group"

"Find resources tagged with environment=staging"

"How many VMs do I have across all subscriptions?"

"List my Key Vaults"

What happens: Copilot queries Azure Resource Graph to find and list your resources. Faster than clicking through the portal, and you can filter by type, tag, resource group, or subscription.

Visualizing Architecture

Skill: azure-resource-visualizer

"Generate an architecture diagram of my resource group 'prod-rg'"

"Visualize the resources in my production environment"

"Show me how the resources in 'api-rg' are connected"

What happens: Copilot analyzes the resources in a resource group and generates a Mermaid architecture diagram showing the relationships between them – which app connects to which database, which services share a virtual network, etc.

🖥️ Choosing the Right Compute

Skill: azure-compute

"What VM size should I use for a Python ML training job with 64GB RAM and a GPU?"

"Recommend the cheapest VM for a small web server"

"Compare D-series vs E-series VMs for a memory-intensive database workload"

"I need a burstable VM for a dev/test environment - what are my options?"

"What's the best VM for running a large PostgreSQL database?"

"Should I use a VM Scale Set or individual VMs for my web tier?"

What happens: Copilot recommends VM sizes based on your workload, pulls real-time pricing from the Azure Retail Prices API, and explains the trade-offs. No Azure account needed – this works for planning too.

🐛 Debugging and Diagnostics

Skill: azure-diagnostics

"My container app is returning 503 errors - what's wrong?"

"Show me the errors from my function app in the last 24 hours"

"Why is my container app failing to pull its image?"

"Analyze the health probe failures for my app 'checkout-api'"

"My Azure Function keeps timing out - help me find the bottleneck"

"What's causing cold start latency on my function app?"

What happens: Copilot runs KQL queries against your Log Analytics workspace, correlates events across logs and metrics, identifies the failure chain, and suggests specific fixes. You describe the symptom; Copilot finds the root cause.

🔐 Security, Compliance, and Identity

RBAC and Permissions

Skill: azure-rbac

"What's the least-privilege role for reading blobs from a storage account?"

"What role should I assign to a managed identity that needs to push images to ACR?"

"Generate the CLI command to assign the Contributor role on my resource group"

"Create a custom role definition that allows starting/stopping VMs but not deleting them"

What happens: Copilot recommends the right RBAC role following least-privilege principles, then generates the az role assignment CLI commands and Bicep code to apply it.

Compliance Scanning

Skill: azure-compliance

"Run a compliance scan on my subscription"

"Check for expiring secrets and certificates in my Key Vaults"

"Are any of my resources misconfigured from a security standpoint?"

"Find resources that don't follow Azure best practices"

What happens: Copilot audits your resources against Azure best practices, checks Key Vault expiration dates, and validates security configurations. Surfaces issues before your security team does.

App Registration and Authentication

Skill: entra-app-registration

"Create a new Entra ID app registration for my web API"

"Set up OAuth 2.0 authentication for my Node.js app"

"Generate an MSAL example for a Python console app that calls Microsoft Graph"

"Add API permissions for Microsoft Graph User.Read to my app registration"

What happens: Copilot walks through the full app registration flow – creating the registration, configuring redirect URIs, setting API permissions, and generating working MSAL code in your language of choice.

🤖 AI and Foundry

Building AI Apps

Skill: azure-ai

"Set up Azure AI Search with vector search for my documents"

"How do I add speech-to-text to my app using Azure Speech Services?"

"Configure hybrid search with semantic ranking on my search index"

"Set up Azure Document Intelligence to extract data from invoices"

What happens: Copilot generates the SDK setup, configuration, and working code for Azure AI services – Search, Speech, OpenAI, and Document Intelligence.

Foundry Agent Workflows

Skill: microsoft-foundry

"Deploy a GPT-4o model through Microsoft Foundry"

"Create a new Foundry agent that can answer questions about my product docs"

"Run an evaluation on my agent using a test dataset"

"What AI models are available in the Foundry catalog?"

What happens: Copilot manages the full Foundry lifecycle – deploying models, creating agents, running evaluations, and managing projects – using the Foundry MCP Server.

API Gateway for AI

Skill: azure-aigateway

"Set up Azure API Management as an AI Gateway in front of my Azure OpenAI models"

"Add semantic caching and token rate limiting to my AI endpoint"

"Configure content safety and jailbreak detection on my AI gateway"

What happens: Copilot configures Azure API Management with AI-specific policies – semantic caching, token limits, content safety, and load balancing across AI model backends.

☁️ Migration

Skill: azure-cloud-migrate

"Assess my AWS Lambda functions for migration to Azure Functions"

"Migrate this AWS CDK stack to Azure Bicep"

"Generate a migration readiness report for moving from AWS to Azure"

"Convert this S3 + Lambda architecture to Azure equivalents"

What happens: Copilot generates a migration assessment report, maps AWS/GCP services to Azure equivalents, and converts infrastructure code. Useful for cross-cloud migrations or evaluating Azure as an alternative.

📊 Data and Observability

Application Insights

Skill: appinsights-instrumentation

"Add Application Insights telemetry to my Express.js API"

"Set up distributed tracing for my microservices"

"What telemetry should I collect for a Python Flask app?"

What happens: Copilot generates the SDK setup, configuration, and telemetry patterns for instrumenting your app with Application Insights. Covers custom events, dependencies, and distributed tracing.

Kusto / Azure Data Explorer

Skill: azure-kusto

"Write a KQL query to find the top 10 slowest API requests in the last hour"

"Analyze my IoT telemetry data for anomalies in the last 7 days"

"Query my ADX cluster for time-series data on sensor readings"

What happens: Copilot generates and runs KQL queries against Azure Data Explorer, helping you analyze logs, telemetry, and time-series data without memorizing KQL syntax.

📦 Storage and Messaging

Storage

Skill: azure-storage

"Upload files to Azure Blob Storage from my Node.js app"

"Set up lifecycle management to move old blobs to cool storage"

"Create an Azure File Share for my container app"

"What's the difference between hot, cool, and archive storage tiers?"

What happens: Copilot generates working code for Blob, File, Queue, and Table storage operations, and configures lifecycle policies and access tiers.

Messaging

Skill: azure-messaging

"My Event Hub consumer is disconnecting - help me troubleshoot"

"Set up a Service Bus queue with dead-letter handling in Python"

"Why am I getting AMQP errors on my Event Hub connection?"

What happens: Copilot troubleshoots Azure messaging SDK issues (Event Hubs, Service Bus) and generates correctly configured producer/consumer code.

🗄️ Databases

PostgreSQL

Skill: azure-postgres

"Create a new Azure PostgreSQL Flexible Server"

"Set up passwordless authentication with Entra ID for my Postgres database"

"Migrate from password-based auth to managed identity for my PostgreSQL connection"

What happens: Copilot provisions PostgreSQL Flexible Server and configures passwordless authentication using Entra ID managed identities – the modern, more secure approach to database auth.

Cosmos DB

Skill: cosmosdb-best-practices

"Optimize my Cosmos DB queries - they're running slow"

"What's the best partition key for a multi-tenant SaaS application?"

"Review my Cosmos DB data model for performance issues"

What happens: Copilot applies Azure Cosmos DB best practices for partitioning, indexing, SDK usage, and query optimization.

🔧 Infrastructure and DevOps

Copilot SDK Apps

Skill: azure-hosted-copilot-sdk

"Build a GitHub Copilot SDK app and deploy it to Azure"

"Set up a Copilot-powered chat app that uses Azure OpenAI as the model backend"

"Scaffold a Copilot SDK project with BYOM (bring your own model) support"

What happens: Copilot scaffolds a complete Copilot SDK application – including session management, model configuration, and Azure deployment infrastructure.

🧭 Prompting Tips

Now that you’ve seen the full prompt catalog, here are a few tips to get the best results:

Be Specific About Your Stack

The more context you give, the better the skill performs.

Vague	Better
“Deploy my app”	“Deploy my Python FastAPI app to Azure Container Apps”
“Fix my Azure errors”	“My container app `checkout-api` is returning 503s since 6 AM”
“Set up a database”	“Create a PostgreSQL Flexible Server with Entra ID auth for my Node.js API”

Name Your Resources

When you include resource names, Copilot can query them directly instead of asking follow-up questions.

"Show me errors from the container app 'payments-api' in the last 4 hours"

Chain Prompts for Complex Workflows

You can build up a full workflow by chaining natural prompts:

1. "What Azure services would I need for this project?"
2. "Prepare it for Azure Container Apps with a PostgreSQL backend"
3. "Validate the configuration"
4. "Deploy it"
5. "Set up Application Insights monitoring"
6. "Run a cost optimization scan"

Each prompt activates the right skill automatically. You just describe what you want next.

Ask About Trade-offs

Skills are great at explaining Azure decisions, not just executing them.

"Should I use Container Apps or App Service for this API?"

"What's the trade-off between Bicep and Terraform for this project?"

"Is a VM Scale Set or AKS better for my autoscaling needs?"

Quick Reference: Skills × Prompts

Skill	Trigger Example	Category
`azure-prepare`	“Prepare this for Azure”	Deploy
`azure-validate`	“Validate my config”	Deploy
`azure-deploy`	“Deploy to Azure”	Deploy
`azure-cost-optimization`	“Find Azure savings”	Cost
`azure-quotas`	“Check my vCPU quota”	Cost
`azure-resource-lookup`	“List my storage accounts”	Explore
`azure-resource-visualizer`	“Diagram my resource group”	Explore
`azure-compute`	“Recommend a VM size”	Compute
`azure-diagnostics`	“Debug my container app”	Ops
`azure-rbac`	“Least-privilege role for blobs”	Security
`azure-compliance`	“Run a compliance scan”	Security
`entra-app-registration`	“Create an app registration”	Security
`azure-ai`	“Set up vector search”	AI
`microsoft-foundry`	“Deploy a model in Foundry”	AI
`azure-aigateway`	“Add AI gateway policies”	AI
`azure-cloud-migrate`	“Migrate from AWS”	Migration
`appinsights-instrumentation`	“Add App Insights to my app”	Observability
`azure-kusto`	“Write a KQL query”	Data
`azure-storage`	“Upload to Blob Storage”	Storage
`azure-messaging`	“Troubleshoot Event Hub”	Messaging
`azure-postgres`	“Passwordless Postgres auth”	Database
`cosmosdb-best-practices`	“Optimize Cosmos DB queries”	Database
`azure-hosted-copilot-sdk`	“Build a Copilot SDK app”	Build

What’s Next

Now that you’ve seen what you can ask, a future post will dive into how skills and MCP servers work together under the hood – the architecture that makes all of this possible.

🚀 Try It Yourself

Install the plugin: aka.ms/azure-plugin
Open Copilot Chat in Agent mode
Pick any prompt from this post and try it
Chain 2–3 prompts together to build a workflow

The best way to learn what the skills can do is to try them. Start with your real project and real Azure subscription – the prompts above work on your actual resources, not demo environments.

👉 Plugin repo: aka.ms/azure-skills