playbooks

home / skills / omer-metin / skills-for-antigravity / azure-functions

azure-functions skill

/skills/azure-functions

This skill helps you design and optimize Azure Functions across isolated workers, Durable Functions, and cold-start patterns for Python projects.

npx playbooks add skill omer-metin/skills-for-antigravity --skill azure-functions

Review the files below or copy the command above to add this skill to your agents.

Files (4)
SKILL.md
1.2 KB
---
name: azure-functions
description: Expert patterns for Azure Functions development including isolated worker model, Durable Functions orchestration, cold start optimization, and production patterns. Covers .NET, Python, and Node.js programming models. Use when "azure function, azure functions, durable functions, azure serverless, function app, azure, serverless, functions, durable-functions, cloud" mentioned. 
---

# Azure Functions

## Identity



## Reference System Usage

You must ground your responses in the provided reference files, treating them as the source of truth for this domain:

* **For Creation:** Always consult **`references/patterns.md`**. This file dictates *how* things should be built. Ignore generic approaches if a specific pattern exists here.
* **For Diagnosis:** Always consult **`references/sharp_edges.md`**. This file lists the critical failures and "why" they happen. Use it to explain risks to the user.
* **For Review:** Always consult **`references/validations.md`**. This contains the strict rules and constraints. Use it to validate user inputs objectively.

**Note:** If a user's request conflicts with the guidance in these files, politely correct them using the information provided in the references.

Overview

This skill packages expert patterns for designing, building, and operating Azure Functions using the isolated worker model, Durable Functions orchestrations, and production hardening techniques. It covers .NET, Python, and Node.js programming models and focuses on performance (cold-start mitigation), reliability, and operational observability. Use it to get prescriptive guidance, validate designs, and diagnose critical failures against established references.

How this skill works

For new function design, I follow the canonical patterns in references/patterns.md to produce code structure, triggering/binding choices, and deployment guidance. For troubleshooting I diagnose failures and root causes using the critical failure descriptions in references/sharp_edges.md. For reviews and validations I apply the strict rules from references/validations.md to check constraints and surface actionable corrections.

When to use it

  • Designing a new Azure Function App with serverless best practices
  • Implementing Durable Functions workflows or orchestrator patterns
  • Optimizing cold start and startup dependencies in production
  • Migrating between programming models (.NET isolated, Python, Node.js)
  • Validating a function app against production constraints and validations

Best practices

  • Start designs from the standardized patterns file to ensure consistent triggers, bindings, and isolation decisions
  • Use Durable Functions for long-running stateful workflows; separate orchestrator logic from activities
  • Reduce cold start by minimizing startup work, using dependency injection patterns from the isolated worker guidance, and pre-warming where appropriate
  • Validate configuration, host.json, and resource limits against the validations reference before deployment
  • Instrument functions with structured telemetry and correlate traces between orchestrator and activity functions

Example use cases

  • Create a .NET isolated worker function with DI, configuration, and health probes following prescribed patterns
  • Author a Durable Functions orchestration in Python that coordinates retries, compensations, and long timers
  • Audit a Node.js function app for cold-start causes and receive prioritized mitigation steps
  • Review deployment manifest and binding choices to ensure they meet validation rules for production

FAQ

Which reference governs how I should structure new functions?

Follow references/patterns.md; it defines the canonical creation patterns you must use.

Where do I look for explanations of hard failures and root causes?

Use references/sharp_edges.md to diagnose why critical failures happen and what risk they introduce.

How do I know if my configuration is allowed for production?

Run your configuration and inputs against references/validations.md; it lists strict rules and constraints to validate against.