Azure Architecture Autopilot
GitHubOfficialFirst committed by whoniiiiDistributed by GitHub
- Skill
- Workflow
- Cloud and DevOps
- MIT
- Low risk
- Has scripts
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
1 of its files are not mirrored here, so install it from its source:
https://github.com/github/awesome-copilot/tree/797337f33f73e35d08d82f840e21c4b8c4932d88/skills/azure-architecture-autopilot
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)
| Feature | Tool Name | Notes |
|---|---|---|
| Fetch URL content | web_fetch | For MS Docs lookups, etc. |
| Web search | web_search | URL discovery |
| Ask user | ask_user | choices must be a string array |
| Sub-agents | task | explore/task/general-purpose |
| Shell command execution | powershell | Windows PowerShell |
All sub-agents (explore/task/general-purpose) cannot use
web_fetchorweb_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 Question | Preload Simultaneously |
|---|---|
| Project name / scan scope | Reference files, MS Docs, Python path discovery, diagram module path verification |
| Model/SKU selection | MS Docs for next question choices |
| Architecture confirmation | az account show/list, az group list |
| Subscription selection | az 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 → deployPath 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 aboveWhen 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/*.mdfileWhen 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.htmlmust 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
| Category | Handling Method | Examples |
|---|---|---|
| Stable | Reference files first | isHnsEnabled: true, PE triple set |
| Dynamic | Always fetch MS Docs | API version, model availability, SKU, region |
Quick Reference
| File | Role |
|---|---|
references/phase0-scanner.md | Existing resource scan + relationship inference + diagram |
references/phase1-advisor.md | Interactive architecture design + fact checking |
references/bicep-generator.md | Bicep code generation rules |
references/bicep-reviewer.md | Code review checklist |
references/phase4-deployer.md | validate → what-if → deploy |
references/service-gotchas.md | Required properties, PE mappings |
references/azure-dynamic-sources.md | MS Docs URL registry |
references/azure-common-patterns.md | PE/security/naming patterns |
references/ai-data.md | AI/Data service guide |
assets/06-architecture-diagram.png | Example generated architecture diagram |
assets/07-azure-portal-resources.png | Example Azure portal resource view |
assets/08-deployment-succeeded.png | Example successful deployment result |
Files
- .gitignore508 B
- ATTRIBUTION.mdAdded by AutoGineer889 B
- LICENSELicence file added by AutoGineer1.0 KiB
- SKILL.md7.5 KiB
- assets/06-architecture-diagram.png326.8 KiB
- assets/07-azure-portal-resources.png171.4 KiB
- assets/08-deployment-succeeded.png41.0 KiB
- references/ai-data.md7.1 KiB
- references/architecture-guidance-sources.md6.9 KiB
- references/azure-common-patterns.md4.2 KiB
- references/azure-dynamic-sources.md4.7 KiB
- references/bicep-generator.md19.9 KiB
- references/bicep-reviewer.md7.1 KiB
- references/phase0-scanner.md24.9 KiB
- references/phase1-advisor.md46.9 KiB
- references/phase4-deployer.md11.7 KiB
- references/service-gotchas.md6.4 KiB
- scripts/cli.pyScript5.7 KiB
- scripts/generator.pyScript137.2 KiB
- scripts/icons.py(opens on GitHub)Not mirrored: opens on GitHub2.0 MiB
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>&1Collect 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 Type | Action | Reason |
|---|---|---|
| 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-is | Adding properties can cause deployment failures due to compatibility issues (e.g., computeMode) |
| BCP187 (sku/kind type unverified) | Leave as-is | Values confirmed from MS Docs will work correctly at deployment |
| no-hardcoded-env-urls | Leave as-is | DNS 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
customSubDomainNamesetting 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
High (Recommended Fix)
[ ] Storage
allowBlobPublicAccess: false,minimumTlsVersion: 'TLS1_2'[ ] Private DNS Zone VNet Link
registrationEnabled: false[ ] Resource types and kind values per service match
references/ai-data.mdor MS Docs[ ] Model deployments: Order guaranteed (
dependsOn)[ ] No sensitive values in parameter files — Remove immediately if found
Medium (Recommended)
[ ] 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 viaparam 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 tokind: '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
whoniiii
- 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