+- Arduino docs home:
+- Getting started path:
+- Arduino IDE usage:
+- Arduino language reference:
+- Arduino programming reference overview:
+- Arduino memory guide:
+- Arduino debugging fundamentals:
+- Arduino low-power design guide:
+- Arduino communication protocols index:
+- Arduino style guide for libraries:
+
+## Firmware Best Practices
+
+- Keep the `loop()` non-blocking; avoid long `delay()` usage in production logic.
+- Use `millis()`-based scheduling for periodic tasks.
+- Budget SRAM explicitly and avoid dynamic allocation in hot paths.
+- Validate sensor ranges and provide safe defaults for invalid readings.
+- Add startup self-checks and periodic health heartbeat messages.
+- Version the payload schema and firmware version in every telemetry stream.
+- Implement retry with exponential backoff and jitter for network operations.
+- Store credentials outside source code and rotate them according to policy.
+
+## Hardware and Power Best Practices
+
+- Document voltage levels, pin mapping, and current limits per peripheral.
+- Design for brownout and power fluctuation scenarios.
+- Use watchdog and safe recovery behavior where available.
+- Plan low-power modes for battery deployments and validate wake cycles.
+
+## Integration Best Practices for Azure IoT
+
+- Prefer secure transports (MQTT over TLS) and per-device identity.
+- Define idempotent upstream processing for duplicate message scenarios.
+- Include device health metrics (uptime, reset reason, RSSI where applicable).
+- Validate offline buffering bounds to avoid uncontrolled memory growth.
diff --git a/skills/azure-architecture-autopilot/README.md b/skills/azure-architecture-autopilot/README.md
new file mode 100644
index 000000000..fb605eea3
--- /dev/null
+++ b/skills/azure-architecture-autopilot/README.md
@@ -0,0 +1,188 @@
+Azure Architecture Autopilot
+
+
+ Diseno → Diagrama → Bicep → Despliegue - todo desde lenguaje natural
+
+
+
+ 
+ 
+ 
+ 
+ 
+
+
+
+ Azure Architecture Autopilot disena infraestructura de Azure desde lenguaje natural,
+ genera diagramas interactivos, produce plantillas Bicep modulares y despliega - todo mediante conversacion.
+ Tambien escanea recursos existentes, los visualiza como diagramas de arquitectura y los refina al vuelo.
+
+
+
+
+ 
+
+
+
+ ↑ Auto-generated interactive diagram — drag, zoom, click for details, export to PNG
+
+
+
+ 
+
+ 
+
+
+
+ ↑ Real Azure resources deployed from the generated Bicep templates
+
+
+
+ How It Works •
+ Features •
+ Prerequisites •
+ Usage •
+ Architecture
+
+
+---
+
+## 🔄 How It Works
+
+```
+Path A: "Build me a RAG chatbot on Azure"
+ ↓
+ 🎨 Design → 🔧 Bicep → ✅ Review → 🚀 Deploy
+
+Path B: "Analyze my current Azure resources"
+ ↓
+ 🔍 Scan → 🎨 Modify → 🔧 Bicep → ✅ Review → 🚀 Deploy
+```
+
+| Phase | Role | What Happens |
+|:-----:|------|--------------|
+| **0** | 🔍 Scanner | Scans existing Azure resources via `az` CLI → auto-generates architecture diagram |
+| **1** | 🎨 Advisor | Interactive design through conversation — asks targeted questions with smart defaults |
+| **2** | 🔧 Generator | Produces modular Bicep: `main.bicep` + `modules/*.bicep` + `.bicepparam` |
+| **3** | ✅ Reviewer | Compiles with `az bicep build`, checks security & best practices |
+| **4** | 🚀 Deployer | `validate` → `what-if` → preview diagram → `create` (5-step mandatory sequence) |
+
+---
+
+## ✨ Features
+
+| | Feature | Description |
+|---|---------|-------------|
+| 📦 | **Zero Dependencies** | 605+ Azure icons bundled — no `pip install`, works offline |
+| 🎨 | **Interactive Diagrams** | Drag-and-drop HTML with zoom, click details, PNG export |
+| 🔍 | **Resource Scanning** | Analyze existing Azure infra → auto-generate architecture diagrams |
+| 💬 | **Natural Language** | *"It's slow"*, *"reduce costs"*, *"add security"* → guided resolution |
+| 📊 | **Live Verification** | API versions, SKUs, model availability fetched from MS Docs in real-time |
+| 🔒 | **Secure by Default** | Private Endpoints, RBAC, managed identity — no secrets in files |
+| ⚡ | **Parallel Preload** | Next-phase info loaded while waiting for user input |
+| 🌐 | **Multi-Language** | Auto-detects user language — responds in English, Korean, or any language |
+
+---
+
+## ⚙️ Prerequisites
+
+| Tool | Required | Install |
+|------|:--------:|---------|
+| **GitHub Copilot CLI** | ✅ | [Install guide](https://docs.github.com/copilot/concepts/agents/about-copilot-cli) |
+| **Azure CLI** | ✅ | `winget install Microsoft.AzureCLI` / `brew install azure-cli` |
+| **Python 3.10+** | ✅ | `winget install Python.Python.3.12` / `brew install python` |
+
+> No additional packages required — the diagram engine is bundled in `scripts/`.
+
+### 🤖 Recommended Models
+
+| | Models | Notes |
+|---|--------|-------|
+| 🏆 **Best** | Claude Opus 4.5 / 4.6 | Most reliable for all 5 phases |
+| ✅ **Recommended** | Claude Sonnet 4.5 / 4.6 | Best cost-performance balance |
+| ⚠️ **Minimum** | Claude Sonnet 4, GPT-5.1+ | May skip steps in complex architectures |
+
+---
+
+## 🚀 Usage
+
+### Path A — Build new infrastructure
+
+```
+"Build a RAG chatbot with Foundry and AI Search"
+"Create a data platform with Databricks and ADLS Gen2"
+"Deploy Fabric + ADF pipeline with private endpoints"
+"Set up a microservices architecture with AKS and Cosmos DB"
+```
+
+### Path B — Analyze & modify existing resources
+
+```
+"Analyze my current Azure infrastructure"
+"Scan rg-production and show me the architecture"
+"What resources are in my subscription?"
+```
+
+Then modify through conversation:
+```
+"Add 3 VMs to this architecture"
+"The Foundry endpoint is slow — what can I do?"
+"Reduce costs — downgrade AI Search to Basic"
+"Add private endpoints to all services"
+```
+
+### 📂 Output Structure
+
+```
+/
+├── 00_arch_current.html ← Scanned architecture (Path B)
+├── 01_arch_diagram_draft.html ← Design diagram
+├── 02_arch_diagram_preview.html ← What-if preview
+├── 03_arch_diagram_result.html ← Deployment result
+├── main.bicep ← Orchestration
+├── main.bicepparam ← Parameter values
+└── modules/
+ └── *.bicep ← Per-service modules
+```
+
+---
+
+## 📁 Architecture
+
+```
+SKILL.md ← Lightweight router (~170 lines)
+│
+├── scripts/ ← Embedded diagram engine
+│ ├── generator.py ← Interactive HTML generator
+│ ├── icons.py ← 605+ Azure icons (Base64 SVG)
+│ └── cli.py ← CLI entry point
+│
+└── references/ ← Phase instructions + patterns
+ ├── phase0-scanner.md ← 🔍 Resource scanning
+ ├── phase1-advisor.md ← 🎨 Architecture design
+ ├── bicep-generator.md ← 🔧 Bicep generation
+ ├── bicep-reviewer.md ← ✅ Code review
+ ├── phase4-deployer.md ← 🚀 Deployment pipeline
+ ├── service-gotchas.md ← Required properties & PE mappings
+ ├── azure-common-patterns.md ← Security & naming patterns
+ ├── azure-dynamic-sources.md ← MS Docs URL registry
+ ├── architecture-guidance-sources.md
+ └── ai-data.md ← AI/Data service domain pack
+```
+
+> **Self-contained** — `SKILL.md` is a lightweight router. All phase logic lives in `references/`. The diagram engine is embedded in `scripts/` with no external dependencies.
+
+---
+
+## 📊 Supported Services (70+ types)
+
+All Azure services supported. AI/Data services have optimized templates; others are auto-looked up from MS Docs.
+
+**Key types:** `ai_foundry` · `openai` · `ai_search` · `storage` · `adls` · `keyvault` · `fabric` · `databricks` · `aks` · `vm` · `app_service` · `function_app` · `cosmos_db` · `sql_server` · `postgresql` · `mysql` · `synapse` · `adf` · `apim` · `service_bus` · `logic_apps` · `event_grid` · `event_hub` · `container_apps` · `app_insights` · `log_analytics` · `firewall` · `front_door` · `load_balancer` · `expressroute` · `sentinel` · `redis` · `iot_hub` · `digital_twins` · `signalr` · `acr` · `bastion` · `vpn_gateway` · `data_explorer` · `document_intelligence` ...
+
+
+---
+
+## 📄 License
+
+MIT © [Jeonghoon Lee](https://github.com/whoniiii)
diff --git a/skills/azure-architecture-autopilot/SKILL.md b/skills/azure-architecture-autopilot/SKILL.md
index ac981d075..e60221bee 100644
--- a/skills/azure-architecture-autopilot/SKILL.md
+++ b/skills/azure-architecture-autopilot/SKILL.md
@@ -1,10 +1,10 @@
---
name: azure-architecture-autopilot
description: >
- Design Azure infrastructure using natural language, or analyze existing Azure resources
- to auto-generate architecture diagrams, refine them through conversation, and deploy with Bicep.
+ Disena infraestructura de Azure en lenguaje natural, o analiza recursos existentes de Azure
+ para autogenerar diagramas de arquitectura, refinarlos mediante conversacion y desplegar con Bicep.
- When to use this skill:
+ Cuando usar esta habilidad:
- "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)
@@ -14,7 +14,7 @@ description: >
# 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.
+Un pipeline que disena infraestructura de Azure en lenguaje natural, o analiza recursos existentes para visualizar la arquitectura y continuar con modificacion y despliegue.
The diagram engine is **embedded within the skill** (`scripts/` folder).
No `pip install` needed — it directly uses the bundled Python scripts
diff --git a/skills/azure-smart-city-iot-solution-builder/SKILL.md b/skills/azure-smart-city-iot-solution-builder/SKILL.md
new file mode 100644
index 000000000..ceb272fc8
--- /dev/null
+++ b/skills/azure-smart-city-iot-solution-builder/SKILL.md
@@ -0,0 +1,157 @@
+---
+name: azure-smart-city-iot-solution-builder
+description: 'Disenar y planificar soluciones Azure IoT y Smart City de extremo a extremo: requisitos, arquitectura, seguridad, operaciones, coste y plan de entrega por fases con artefactos concretos de implementacion.'
+---
+
+# Azure Smart City IoT Solution Builder
+
+Usa esta habilidad para reconstruir y estandarizar un flujo completo para construir soluciones Azure IoT y Smart City.
+
+## Cuando usarla
+
+Usa esta habilidad cuando el usuario pida cosas como:
+
+- "quiero montar una solucion IoT en Azure"
+- "arquitectura Smart City para trafico, alumbrado o residuos"
+- "como conecto dispositivos, analitica y alertas"
+- "necesito roadmap y backlog para una plataforma urbana"
+
+## Objetivos
+
+- Convertir una idea de alto nivel en una arquitectura desplegable.
+- Reutilizar habilidades existentes enfocadas en Azure cuando sea posible.
+- Producir artefactos concretos que el equipo pueda implementar.
+
+## Flujo de trabajo
+
+### 0) Revision obligatoria de documentacion (antes de cualquier arquitectura)
+
+Antes de proponer arquitectura o decisiones tecnologicas que involucren computacion en el borde, el asistente debe revisar primero la documentacion de Azure IoT Edge:
+
+- https://learn.microsoft.com/azure/iot-edge/
+- https://learn.microsoft.com/es-es/azure/iot-edge/
+
+Paginas minimas a revisar:
+
+- Que es Azure IoT Edge
+- Arquitectura de runtime
+- Sistemas compatibles
+- Historial de versiones/notas de lanzamiento
+- Guias de inicio rapido de Linux/Windows relevantes para el escenario
+
+Si no se puede consultar la documentacion, indicalo explicitamente y continua con supuestos claramente marcados.
+
+### 1) Alcance y restricciones
+
+Recoge y confirma:
+
+- Dominio de ciudad: movilidad, parking, calidad del aire, agua, energia, seguridad, residuos, etc.
+- Escala: numero de dispositivos, frecuencia de telemetria, retencion, regiones.
+- Objetivos de latencia y disponibilidad.
+- Restricciones regulatorias y de privacidad.
+- Sistemas existentes a integrar (SCADA, GIS, ERP, ticketing, APIs).
+
+### 2) Mapa de capacidades
+
+Divide la plataforma en capas:
+
+- Dispositivo y edge: incorporacion, identidad, firmware, OTA, procesamiento en el borde.
+- Ingestion y mensajeria: mando y control, enrutado de eventos, almacenamiento en buffer.
+- Datos y analitica: ruta caliente frente a ruta fria, paneles, analisis historico.
+- Operaciones: observabilidad, flujo de incidentes, SLO.
+- Gobierno: RBAC, secretos, politicas, aislamiento de red.
+
+### 3) Seleccion de servicios de Azure (referencia)
+
+- Conectividad de dispositivos: Azure IoT Hub, Azure IoT Operations, IoT Edge.
+- Streaming de eventos: Event Hubs, Service Bus, Event Grid.
+- Almacenamiento: Blob Storage, Data Lake, Cosmos DB, SQL.
+- Analitica: Azure Data Explorer, Stream Analytics, Fabric/Synapse.
+- API y aplicaciones: API Management, App Service, Container Apps, Functions.
+- Monitorizacion: Azure Monitor, Application Insights, Log Analytics.
+- Seguridad: Key Vault, Defender for IoT, Private Endpoints, Managed Identity.
+
+### 4) Diseno no funcional
+
+Define y documenta:
+
+- Modelo de fiabilidad (zonas/regiones, reintentos, dead-letter, replay).
+- Controles de seguridad (confianza cero, cifrado, rotacion de secretos, minimo privilegio).
+- Controles de coste (niveles de retencion, ajuste de tamano, autoescalado, planificacion de cargas).
+- Ciclo de vida de datos (bruto, curado, agregado, archivado).
+
+### 5) Plan de entrega
+
+Crea una ejecucion por fases:
+
+- Fase 1: Distrito piloto o caso de uso unico.
+- Fase 2: Integracion multi-dominio.
+- Fase 3: Despliegue a escala ciudad y optimizacion.
+
+Para cada fase incluye:
+
+- Criterios de salida
+- Dependencias
+- Riesgos y mitigaciones
+- Conjunto de KPI
+
+## Reutilizar otras habilidades primero
+
+Hay dos fuentes de habilidades:
+
+- Habilidades proporcionadas por runtime (externas a este repositorio): solo disponibles cuando el entorno host de Copilot las expone.
+- Habilidades locales del repositorio (este repositorio): disponibles como archivos locales bajo `skills/`.
+
+### Habilidades de Azure proporcionadas por runtime (opcionales)
+
+Si estan disponibles en el entorno de ejecucion, deriva a estas habilidades especializadas para mas profundidad:
+
+- `azure-kubernetes`
+- `azure-messaging`
+- `azure-observability`
+- `azure-storage`
+- `azure-rbac`
+- `azure-cost`
+- `azure-validate`
+- `azure-deploy`
+
+### Alternativas locales del repositorio (usar en este repo)
+
+Cuando las habilidades de runtime no esten disponibles, prioriza las habilidades locales existentes en este repositorio:
+
+- `azure-architecture-autopilot` para generacion y refinamiento de arquitectura.
+- `azure-resource-visualizer` para diagramas de relacion entre recursos.
+- `azure-role-selector` para orientacion de seleccion de roles.
+- `az-cost-optimize` y `azure-pricing` para analisis de costes y precios.
+- `azure-deployment-preflight` para comprobaciones previas al despliegue.
+- `appinsights-instrumentation` para patrones de instrumentacion de telemetria.
+
+Si no hay ninguna habilidad especializada disponible, continua con esta habilidad y deja los supuestos explicitos.
+
+## Artefactos de salida requeridos
+
+Entrega siempre estas salidas:
+
+1. Resumen de solucion Smart City (alcance, supuestos, restricciones).
+2. Arquitectura de referencia (componentes y flujo de datos).
+3. Checklist de seguridad y gobierno.
+4. Estrategia de coste y escalado.
+5. Backlog de implementacion por fases (epicas e hitos).
+
+## Plantilla de salida
+
+Usa esta estructura en las respuestas:
+
+1. Contexto y objetivos
+2. Arquitectura propuesta
+3. Decisiones tecnologicas y compromisos
+4. Seguridad, operaciones y controles de coste
+5. Plan de implementacion por fases
+6. Riesgos y preguntas abiertas
+
+## Directrices
+
+- No saltes a despliegue sin validar antes los prerequisitos.
+- No recomiendes produccion en region unica para cargas criticas de ciudad.
+- No omitas la responsabilidad operativa (quien gestiona incidentes, SLA, ventanas de cambio).
+- Separa claramente los supuestos de los hechos confirmados.
diff --git a/skills/azure-smart-city-iot-solution-builder/references/smart-city-solution-template.md b/skills/azure-smart-city-iot-solution-builder/references/smart-city-solution-template.md
new file mode 100644
index 000000000..43573d29f
--- /dev/null
+++ b/skills/azure-smart-city-iot-solution-builder/references/smart-city-solution-template.md
@@ -0,0 +1,73 @@
+# Plantilla de Solucion IoT Smart City
+
+Usa esta plantilla para estandarizar resultados en cada nuevo escenario de ciudad inteligente.
+
+## 1. Resumen del caso de uso
+
+- Dominio:
+- Interesados:
+- Enunciado del problema:
+- Metricas de exito:
+
+## 2. Perfil de datos y dispositivos
+
+- Tipos y cantidad de dispositivos:
+- Esquema de telemetria:
+- Tasa de ingestion:
+- Requisitos de mando/control:
+- Politica de retencion:
+
+## 3. Arquitectura de referencia
+
+- Capa de edge y campo:
+- Capa de ingestion:
+- Capa de procesamiento:
+- Capa de almacenamiento:
+- Capa de API e integracion:
+- Capa de monitorizacion y seguridad:
+
+## 4. Checklist de NFR
+
+- Objetivo de disponibilidad:
+- Objetivo de latencia:
+- Controles de seguridad:
+- Restricciones de privacidad de datos:
+- Estrategia de DR:
+- Objetivo de coste:
+
+## 5. Roadmap por fases
+
+### Fase 1 - Piloto
+
+- Alcance:
+- Entregables:
+- Criterios de salida:
+
+### Fase 2 - Escalar
+
+- Alcance:
+- Entregables:
+- Criterios de salida:
+
+### Fase 3 - Optimizar
+
+- Alcance:
+- Entregables:
+- Criterios de salida:
+
+## 6. Base inicial del backlog
+
+- Epica: Incorporacion de dispositivos e identidad
+- Epica: Ingestion y enrutado de telemetria
+- Epica: Alertado en tiempo real y flujo de incidentes
+- Epica: Analitica historica e informes
+- Epica: Refuerzo de seguridad y cumplimiento
+- Epica: Gobierno y optimizacion de costes
+
+## 7. Riesgos
+
+- Brechas de interoperabilidad entre proveedor/dispositivo
+- Fiabilidad de red en ubicaciones de campo
+- Calidad de datos y deriva de esquemas
+- Sobre-retencion que incrementa costes
+- Ambiguedad en la responsabilidad operativa
diff --git a/skills/python-azure-iot-edge-modules/SKILL.md b/skills/python-azure-iot-edge-modules/SKILL.md
new file mode 100644
index 000000000..8282534a7
--- /dev/null
+++ b/skills/python-azure-iot-edge-modules/SKILL.md
@@ -0,0 +1,139 @@
+---
+name: python-azure-iot-edge-modules
+description: 'Build and operate Python Azure IoT Edge modules with robust messaging, deployment manifests, observability, and production readiness checks.'
+---
+
+# Python Azure IoT Edge Modules
+
+Use this skill to design, implement, and validate Python-based IoT Edge modules for telemetry processing, local inference, protocol translation, and edge-to-cloud integration.
+
+## When To Use
+
+Use this skill for requests like:
+
+- "quiero crear un modulo Python para IoT Edge"
+- "como despliego modulos edge con manifest"
+- "necesito filtrar/agregar telemetria antes de subirla"
+- "como manejo desconexiones y reintentos en edge"
+
+## Mandatory Docs Review
+
+Before recommending runtime behavior or deployment decisions, review:
+
+- https://learn.microsoft.com/azure/iot-edge/
+- https://learn.microsoft.com/es-es/azure/iot-edge/
+
+Minimum checks:
+
+- Runtime architecture and module lifecycle.
+- Supported host OS and versions.
+- Deployment model and configuration flow.
+- Current release/version guidance.
+
+If documentation cannot be fetched, proceed with explicit assumptions and flag them clearly.
+
+## Python Official References and Best Practices (Required)
+
+Before proposing Python implementation details, consult official Python sources:
+
+- https://www.python.org/
+- https://docs.python.org/3/
+- https://docs.python.org/3/reference/
+- https://docs.python.org/3/library/
+- references/python-official-best-practices.md
+
+Prefer official docs over community snippets unless there is a specific compatibility reason to deviate.
+
+## Goals
+
+- Deliver module architecture and implementation plan that is production-focused.
+- Ensure reliable edge messaging under network variability.
+- Provide deployment, observability, and validation artifacts.
+
+## Module Use Cases
+
+- Protocol adapter (serial/Modbus/OPC-UA to IoT message format).
+- Telemetry enrichment and normalization.
+- Local anomaly detection or inference.
+- Command orchestration and local actuator control.
+
+## Delivery Workflow
+
+### 1) Contract and Interfaces
+
+Define:
+
+- Module inputs and outputs.
+- Message schema and versioning policy.
+- Routes and priorities for normal vs critical telemetry.
+- Desired properties used for dynamic configuration.
+
+### 2) Runtime and Packaging
+
+Specify:
+
+- Python runtime version target.
+- Container image strategy (base image, slim footprint, CVE hygiene).
+- Resource profile (CPU/memory bounds).
+- Startup and health checks.
+
+### 3) Reliability Design
+
+Implement and validate:
+
+- Retries with exponential backoff and jitter.
+- Graceful degradation on upstream failures.
+- Local queueing strategy where needed.
+- Idempotent processing for replayed messages.
+
+### 4) Security Controls
+
+Require:
+
+- No plaintext secrets in code or manifest.
+- Least-privilege module behavior.
+- Secure transport and trusted cert chain handling.
+- Traceability for command handling and state changes.
+
+### 5) Deployment and Operations
+
+Define:
+
+- Environment-specific deployment manifests.
+- Rollout strategy (pilot, staged, broad).
+- Rollback criteria.
+- SLOs and alerting conditions.
+
+## Reuse Other Skills
+
+When relevant, combine with:
+
+- `azure-smart-city-iot-solution-builder` for platform-level architecture.
+- `appinsights-instrumentation` for telemetry instrumentation approaches.
+- `azure-resource-visualizer` for architecture diagrams and dependency mapping.
+
+Also use `references/python-official-best-practices.md` as baseline quality criteria for module design and implementation guidance.
+
+## Required Output
+
+Always provide:
+
+1. Module design brief (purpose, inputs, outputs).
+2. Deployment model (image, manifest, env settings).
+3. Reliability and error-handling strategy.
+4. Security and operations checklist.
+5. Test matrix (functional, chaos, performance, rollback).
+
+## Output Template
+
+1. Context and assumptions
+2. Module architecture
+3. Deployment and configuration
+4. Reliability, security, observability
+5. Validation and rollout plan
+
+## Guardrails
+
+- Do not recommend direct production rollout without pilot stage.
+- Do not embed secrets in Dockerfiles, source, or manifests.
+- Do not omit health probes, restart behavior, and rollback criteria.
diff --git a/skills/python-azure-iot-edge-modules/references/python-edge-module-template.md b/skills/python-azure-iot-edge-modules/references/python-edge-module-template.md
new file mode 100644
index 000000000..8b36630f9
--- /dev/null
+++ b/skills/python-azure-iot-edge-modules/references/python-edge-module-template.md
@@ -0,0 +1,63 @@
+# Python IoT Edge Module Template
+
+Use this template to structure implementation proposals and reviews.
+
+## 0) Official Python Baseline
+
+- Official references reviewed from and .
+- Language and stdlib usage validated against and .
+- Best practices reviewed from `references/python-official-best-practices.md`.
+
+## 1) Module Summary
+
+- Module name:
+- Business capability:
+- Inputs:
+- Outputs:
+- Trigger conditions:
+
+## 2) Message Contract
+
+- Schema version:
+- Required fields:
+- Optional fields:
+- Error payload contract:
+
+## 3) Runtime Configuration
+
+- Python version:
+- Base image:
+- Environment variables:
+- Desired properties:
+- Resource limits:
+
+## 4) Resilience
+
+- Retry policy:
+- Backoff policy:
+- Queueing strategy:
+- Idempotency approach:
+- Timeout and circuit-breaker behavior:
+
+## 5) Security
+
+- Secret source (never inline):
+- Identity and permissions:
+- Command authorization model:
+- Audit log requirements:
+
+## 6) Observability
+
+- Health signals:
+- Business metrics:
+- Error metrics:
+- Correlation/trace requirements:
+- Alert thresholds:
+
+## 7) Validation Matrix
+
+- Happy path tests:
+- Malformed payload tests:
+- Network interruption tests:
+- Throughput and latency tests:
+- Rollback validation:
diff --git a/skills/python-azure-iot-edge-modules/references/python-official-best-practices.md b/skills/python-azure-iot-edge-modules/references/python-official-best-practices.md
new file mode 100644
index 000000000..2328e575b
--- /dev/null
+++ b/skills/python-azure-iot-edge-modules/references/python-official-best-practices.md
@@ -0,0 +1,48 @@
+# Python Official References and Best Practices
+
+Use these official Python resources before finalizing module architecture or implementation details.
+
+## Official References
+
+- Python home:
+- Python documentation portal:
+- Python tutorial:
+- Python language reference:
+- Python standard library reference:
+- Python HOWTOs:
+- Installing modules:
+- Distributing modules:
+- PEP index:
+- PyPA packaging guide:
+
+## Coding Best Practices
+
+- Target and pin an explicit Python major/minor runtime for each deployment.
+- Prefer explicit, readable code paths over clever compact logic.
+- Use type hints for public interfaces and critical data transformations.
+- Keep module responsibilities focused; separate protocol, business logic, and transport.
+- Validate and sanitize external inputs at boundaries.
+- Use structured exceptions with actionable error messages.
+- Log with enough context for incident triage (correlation id, module id, message id).
+
+## Reliability and Performance Best Practices
+
+- Avoid blocking operations in high-frequency message paths.
+- Enforce timeouts and bounded retries with exponential backoff and jitter.
+- Design idempotent handlers for replay and duplicate deliveries.
+- Use resource limits and monitor memory growth to prevent edge instability.
+- Define graceful shutdown behavior to flush buffered state safely.
+
+## Dependency and Supply Chain Best Practices
+
+- Pin dependencies and document upgrade cadence.
+- Prefer actively maintained libraries with clear release history.
+- Track vulnerabilities and update dependencies regularly.
+- Keep container images minimal and patched.
+
+## Testing Best Practices
+
+- Unit test parsing, validation, and routing logic.
+- Add integration tests for module I/O boundaries.
+- Add chaos tests for network loss, slow upstream, and restart scenarios.
+- Verify rollback behavior and state recovery in deployment tests.