Generated banner for Azure Architecture Autopilot
Generated logo for Azure Architecture Autopilot

Azure Architecture Autopilot

GitHubOfficialFirst committed by whoniiiiDistributed by GitHub

  • Skill
  • Workflow
  • Cloud and DevOps
  • MIT
  • Low risk
  • Has scripts

From the author

Design Azure infrastructure using natural language, or analyze existing Azure resources to auto-generate architecture diagrams, refine them through conversation, and deploy with Bicep. When to use this skill: - "Create X on Azure", "Set up a RAG architecture" (new design) - "Analyze my current Azure infrastructure", "Draw a diagram for rg-xxx" (existing analysis) - "Foundry is slow", "I want to reduce costs", "Strengthen security" (natural language modification) - Azure resource deployment, Bicep template generation, IaC code generation - Microsoft Foundry, AI Search, OpenAI, Fabric, ADLS Gen2, Databricks, and all Azure services
— the description by whoniiii

AutoGineer summary

Written by AutoGineer from the skill’s own files, not by the author

Azure Architecture Autopilot is a multi-phase agentic workflow designed to assist users in creating or modifying Azure infrastructure. It guides users through an interactive design process, generates architecture diagrams using an embedded engine, produces Bicep templates, and manages the deployment lifecycle. The skill integrates with Azure services and utilizes official Microsoft documentation to ensure configurations align with current service specifications.

What it does

  • Designs new Azure infrastructure based on natural language requirements.
  • Analyzes existing Azure resources to generate visual architecture diagrams.
  • Refines infrastructure designs through interactive conversation.
  • Generates and reviews Bicep templates for infrastructure as code.
  • Executes deployment workflows including validation and what-if analysis.
  • Detects user language to provide localized support and documentation.

When to use it

  • When you need to design a new Azure environment or RAG architecture.
  • When you want to visualize your current Azure resource configuration.
  • When you need to generate or update Bicep templates for Azure deployments.
  • When you require guidance on modifying existing Azure infrastructure to meet new requirements.

Advantages

  • Automated diagram generation using an embedded engine with official Azure icons.
  • Structured multi-phase workflow ensuring design confirmation before deployment.
  • Integration with Microsoft documentation for dynamic service property lookups.
  • Supports natural language interaction for complex infrastructure tasks.
  • Includes built-in safety checks like what-if analysis prior to deployment.

Usage examples

“Create a RAG architecture on Azure.”
The agent will initiate the design phase, suggest a baseline architecture, generate a diagram, and guide you through the Bicep generation and deployment process.
“Analyze my current Azure infrastructure and draw a diagram.”
The agent will scan your existing resources, infer relationships, and produce an interactive HTML diagram of your current setup.
“I want to strengthen security for my existing Azure resources.”
The agent will analyze your current configuration and propose modifications to your infrastructure design to align with security patterns.

Install

Documentation by whoniiii

Azure Architecture Builder

A pipeline that designs Azure infrastructure using natural language, or analyzes existing resources to visualize architecture and proceed through modification and deployment.

The diagram engine is embedded within the skill (scripts/ folder). No pip install needed — it directly uses the bundled Python scripts to generate interactive HTML diagrams with 605+ official Azure icons. Ready to use immediately without network access or package installation.

Automatic User Language Detection

🚨 Detect the language of the user's first message and provide all subsequent responses in that language. This is the highest-priority principle.

  • If the user writes in Korean → respond in Korean

  • If the user writes in English → respond in English (ask_user, progress updates, reports, Bicep comments — all in English)

  • The instructions and examples in this document are written in English, and all user-facing output must match the user's language

⚠️ Do not copy examples from this document verbatim to the user. Use only the structure as reference, and adapt text to the user's language.

Tool Usage Guide (GHCP Environment)

FeatureTool NameNotes
Fetch URL contentweb_fetchFor MS Docs lookups, etc.
Web searchweb_searchURL discovery
Ask userask_userchoices must be a string array
Sub-agentstaskexplore/task/general-purpose
Shell command executionpowershellWindows PowerShell

All sub-agents (explore/task/general-purpose) cannot use web_fetch or web_search. Fact-checking that requires MS Docs lookups must be performed directly by the main agent.

External Tool Path Discovery

az, python, bicep, etc. are often not on PATH. Discover once before starting a Phase and cache the result. Do not re-discover every time.

⚠️ Do not use Get-Command python — risk of Windows Store alias. Direct filesystem discovery ($env:LOCALAPPDATA\Programs\Python) takes priority.

az CLI path:

$azCmd = $null
if (Get-Command az -ErrorAction SilentlyContinue) { $azCmd = 'az' }
if (-not $azCmd) {
  $azExe = Get-ChildItem -Path "$env:ProgramFiles\Microsoft SDKs\Azure\CLI2\wbin", "$env:LOCALAPPDATA\Programs\Azure CLI\wbin" -Filter "az.cmd" -ErrorAction SilentlyContinue | Select-Object -First 1 -ExpandProperty FullName
  if ($azExe) { $azCmd = $azExe }
}

Python path + embedded diagram engine: refer to the diagram generation section in references/phase1-advisor.md.

Progress Updates Required

Use blockquote + emoji + bold format:

> **⏳ [Action]** — [Reason]
> **✅ [Complete]** — [Result]
> **⚠️ [Warning]** — [Details]
> **❌ [Failed]** — [Cause]

Parallel Preload Principle

While waiting for user input via ask_user, preload information needed for the next step in parallel.

ask_user QuestionPreload Simultaneously
Project name / scan scopeReference files, MS Docs, Python path discovery, diagram module path verification
Model/SKU selectionMS Docs for next question choices
Architecture confirmationaz account show/list, az group list
Subscription selectionaz group list

Path Branching — Automatically Determined by User Request

Path A: New Design (New Build)

Trigger: "create", "set up", "deploy", "build", etc.

Phase 1 (references/phase1-advisor.md) — Interactive architecture design + diagram
    ↓
Phase 2 (references/bicep-generator.md) — Bicep code generation
    ↓
Phase 3 (references/bicep-reviewer.md) — Code review + compilation verification
    ↓
Phase 4 (references/phase4-deployer.md) — validate → what-if → deploy
Path B: Existing Analysis + Modification (Analyze & Modify)

Trigger: "analyze", "current resources", "scan", "draw a diagram", "show my infrastructure", etc.

Phase 0 (references/phase0-scanner.md) — Existing resource scan + diagram
    ↓
Modification conversation — "What would you like to change here?" (natural language modification request → follow-up questions)
    ↓
Phase 1 (references/phase1-advisor.md) — Confirm modifications + update diagram
    ↓
Phase 2~4 — Same as above
When Path Determination Is Ambiguous

Ask the user directly:

ask_user({
  question: "What would you like to do?",
  choices: [
    "Design a new Azure architecture (Recommended)",
    "Analyze + modify existing Azure resources"
  ]
})

Phase Transition Rules

  • Each Phase reads and follows the instructions in its corresponding references/*.md file

  • When transitioning between Phases, always inform the user about the next step

  • Do not skip Phases (especially the what-if between Phase 3 → Phase 4)

  • 🚨 Required condition for Phase 1 → Phase 2 transition: 01_arch_diagram_draft.html must have been generated using the embedded diagram engine and shown to the user. Do not proceed to Bicep generation without a diagram. Completing spec collection alone does not mean Phase 1 is done — Phase 1 includes diagram generation + user confirmation.

  • Modification request after deployment → return to Phase 1, not Phase 0 (Delta Confirmation Rule)

Service Coverage & Fallback

Optimized Services

Microsoft Foundry, Azure OpenAI, AI Search, ADLS Gen2, Key Vault, Microsoft Fabric, Azure Data Factory, VNet/Private Endpoint, AML/AI Hub

Other Azure Services

All supported — MS Docs are automatically consulted to generate at the same quality standard. Do not send messages that cause user anxiety such as "out of scope" or "best-effort".

Stable vs Dynamic Information Handling
CategoryHandling MethodExamples
StableReference files firstisHnsEnabled: true, PE triple set
DynamicAlways fetch MS DocsAPI version, model availability, SKU, region

Quick Reference

FileRole
references/phase0-scanner.mdExisting resource scan + relationship inference + diagram
references/phase1-advisor.mdInteractive architecture design + fact checking
references/bicep-generator.mdBicep code generation rules
references/bicep-reviewer.mdCode review checklist
references/phase4-deployer.mdvalidate → what-if → deploy
references/service-gotchas.mdRequired properties, PE mappings
references/azure-dynamic-sources.mdMS Docs URL registry
references/azure-common-patterns.mdPE/security/naming patterns
references/ai-data.mdAI/Data service guide
assets/06-architecture-diagram.pngExample generated architecture diagram
assets/07-azure-portal-resources.pngExample Azure portal resource view
assets/08-deployment-succeeded.pngExample successful deployment result

Files

references/bicep-reviewer.md

Bicep Reviewer Agent

Reviews generated Bicep code and automatically fixes any issues found.

Review Order

Step 1: Bicep Compilation (Run First)

Run actual Bicep compilation before the checklist. Do not declare "pass" based on visual inspection alone.

az bicep build --file main.bicep 2>&1

Collect all WARNINGs and ERRORs from the compilation results. This is the foundational data for the review.

Step 2: Fix Compilation Errors/Warnings

Fix issues found in compilation results:

  • ERROR → Must fix and recompile

  • WARNING → Handle according to the criteria below

🚨 WARNING Handling Criteria — Do Not Force Unnecessary Fixes:

WARNINGs do not block deployment. Attempting to resolve warnings often introduces deployment errors, so use the following criteria:

WARNING TypeActionReason
BCP081 (type not defined)Leave as-is (if API version is the latest confirmed from MS Docs)Local Bicep CLI type definitions are not yet updated. No impact on deployment
BCP035 (missing property)Judge carefully — Check MS Docs to verify if the property is actually required; if not, leave as-isAdding properties can cause deployment failures due to compatibility issues (e.g., computeMode)
BCP187 (sku/kind type unverified)Leave as-isValues confirmed from MS Docs will work correctly at deployment
no-hardcoded-env-urlsLeave as-isDNS Zone names inevitably require hardcoding

Never do the following:

  • Downgrade API versions to resolve WARNINGs (maintain latest stable)

  • Add properties not confirmed in MS Docs to resolve WARNINGs

  • Force fixes targeting "zero warnings"

Principle: Document WARNINGs in review results, but do not fix them if they don't block deployment.

Common issues and responses:

  • BCP081 (type not defined) → API version is likely incorrect. Fetch MS Docs and update to the actual latest stable version

  • BCP036 (type mismatch) → Check property value casing and type, then fix

  • BCP037 (property not allowed) → Check MS Docs to verify if the property is supported in that API version

  • no-hardcoded-env-urls → Hardcoded URLs in DNS Zone names etc. are sometimes unavoidable in Bicep. Note in review results

Step 3: Checklist Review

Review the following items after compilation passes. See references/service-gotchas.md for full gotchas.

Critical (Must Fix)
  • [ ] Microsoft Foundry customSubDomainName setting exists — Cannot be changed after creation; if missing, resource must be deleted and recreated

  • [ ] When using Microsoft Foundry, Foundry Project (accounts/projects) must exist — Portal access unavailable without it

  • [ ] Microsoft Foundry identity: { type: 'SystemAssigned' } — Project creation fails without it

  • [ ] publicNetworkAccess: 'Disabled' — All services using PE

  • [ ] ADLS Gen2 isHnsEnabled: true — Without it, becomes regular Blob Storage

  • [ ] pe-subnet privateEndpointNetworkPolicies: 'Disabled' — PE creation fails without it

  • [ ] Private DNS Zone Group — Must exist for every PE

  • [ ] Key Vault enablePurgeProtection: true

  • [ ] Storage allowBlobPublicAccess: false, minimumTlsVersion: 'TLS1_2'

  • [ ] Private DNS Zone VNet Link registrationEnabled: false

  • [ ] Resource types and kind values per service match references/ai-data.md or MS Docs

  • [ ] Model deployments: Order guaranteed (dependsOn)

  • [ ] No sensitive values in parameter files — Remove immediately if found

  • [ ] Resource name collision prevention using uniqueString()

  • [ ] Leverage implicit dependencies through resource references

Step 4: Hardcoding Regression Check (Prevent Dynamic Information Leakage)

Verify the following items are not hardcoded as literal values in the Bicep code:

Must Be Parameterized (No Hardcoding)
  • [ ] location — Literal region names ('eastus', 'koreacentral', etc.) are not used directly; passed via param location

  • [ ] Model name/version — Not literals; use values confirmed in Phase 1 and validated for availability in Step 0

  • [ ] SKU — Use values confirmed with the user

Verify Dynamic Values Have Not Regressed Into References

This is not directly within this review's scope, but if specific API versions, SKU lists, or region lists are hardcoded in code comments or parameter descriptions, remove them and replace with "Check MS Docs" guidance.

Decision Rule Violation Check
  • [ ] If kind: 'OpenAI' is used instead of Foundry → Change to kind: 'AIServices' unless the user explicitly requested it

  • [ ] If Hub (MachineLearningServices) is used for general AI/RAG → Change to Foundry unless the user explicitly requested it

  • [ ] If a standalone Azure OpenAI resource is used → Suggest reviewing Foundry usage unless the user explicitly requested it or Docs indicate it's necessary

Step 5: Recompile After Fixes

If any changes were made in Steps 2–4, run az bicep build again to verify no new errors were introduced.

Limitations of az bicep build

Compilation only validates syntax and types. The following items cannot be caught by compilation and are finally verified in Phase 4's az deployment group what-if:

  • Retired/unavailable SKU

  • Per-region service availability

  • Model name validity

  • Preview-only properties

  • Service policy changes (quota, capacity, etc.)

State these limitations in the review results so the user understands the importance of the what-if step.

Step 6: Report Results
## Bicep Code Review Results

**Compilation Result**: [PASS/WARNING N items]
**Checklist**: ✅ Passed X items / ⚠️ Warnings X items
**Hardcoding Check**: [PASS / N violations]
**Auto-fixed**: X items

### Compilation Warnings (Remaining)
- [Warning content — including reason why it cannot be fixed]

### Auto-fix Details
- [File:line number] Before → After (reason)

### Hardcoding Violations (If Any)
- [File:line number] [Violation details] → [Fix method]

**Conclusion**: [Ready for deployment / Manual review required]
Step 7: Phase 4 Transition — Reassurance Message Required

When asking whether to proceed to Phase 4 after passing code review, always include a message to reassure the user. Users may feel uneasy about the word "deployment", so clearly communicate that what-if is a safe validation step.

ask_user({
  question: "Code review passed! Ready to proceed to the next step?\n\n⚡ This does NOT deploy immediately:\n  1️⃣ What-if validation — Simulates what will be created (not a deployment, safe)\n  2️⃣ Preview diagram — Review the architecture to be deployed as a diagram\n  3️⃣ Final confirmation — Actual deployment only after you review the diagram and approve\n\nNothing will be deployed without your approval.",
  choices: [
    "Proceed to next step (what-if validation + preview diagram) (Recommended)",
    "Just give me the code, I'll deploy later"
  ]
})

Key points:

  • Always state "This does NOT deploy immediately"

  • Explain the 3-step process: what-if → preview diagram → final confirmation

  • Reassure with "Nothing will be deployed without your approval"

Requirements and compatibility

Written for: GitHub Copilot

Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta

“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.

Needs: Needs Python

Security

What our scanner noticed· Low risk

  • Phrasing that asks for actions without confirmation
  • Instructions that use the network
  • Scripts that your agent may run

This skill includes scripts that your agent may run. Read them before you use it.

A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.

Attribution and licence

First committed by
GitHub avatar of whoniiiiwhoniiii
Publisher
GitHub (Official)
Distributed by
GitHub
Source
github/awesome-copilot · skills/azure-architecture-autopilot · commit 797337f
Licence
MIT License (redistribution allowed)
  • LICENSE (added by AutoGineer from LICENSE)
  • ATTRIBUTION.md (written by AutoGineer)
Synced
Contributors
whoniiii, NehaGitHubAcc, Sertxito, stbenjam

AutoGineer is not affiliated with or endorsed by whoniiii or GitHub.

Get it from the source

1 of this skill’s files are not mirrored here, so there is no ZIP. Get the complete skill from its source: github/awesome-copilot