{"id":3870,"date":"2026-06-02T12:19:59","date_gmt":"2026-06-02T19:19:59","guid":{"rendered":"https:\/\/devblogs.microsoft.com\/azure-sdk\/?p=3870"},"modified":"2026-06-02T12:19:59","modified_gmt":"2026-06-02T19:19:59","slug":"introducing-azure-functions-skills-ai-era-workspace","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/azure-sdk\/introducing-azure-functions-skills-ai-era-workspace\/","title":{"rendered":"Introducing azure-functions-skills: An AI-Era Workspace for Azure Functions (Preview)"},"content":{"rendered":"<p><img decoding=\"async\" src=\"https:\/\/devblogs.microsoft.com\/azure-sdk\/wp-content\/uploads\/sites\/58\/2026\/06\/06-12-introducing-azure-functions-skills-eye-catch.webp\" alt=\"AI coding agents connected to Azure Functions skills\" \/><\/p>\n<p>Today we&#8217;re announcing <strong><code>azure-functions-skills<\/code><\/strong> in <strong>public preview<\/strong>: a one-command way to give your favorite coding agent (GitHub Copilot CLI, Claude Code, Codex CLI, VS Code) the skills, agent definition, MCP servers, hooks, and instructions it needs to ship <strong>secure-by-default, scale-ready<\/strong> Azure Functions \u2014 end-to-end.<\/p>\n<p>AI coding agents now write the first draft of your function, scaffold the infrastructure, and run the deploy command. But ask a general-purpose agent to build for Azure Functions and the output is usually a step behind. It leans on older programming models that have been superseded, and it has no knowledge of newer capabilities: the serverless agents runtime, Flex Consumption defaults, the new Azure MCP template service, the latest binding shapes, this week&#8217;s runtime improvements, or Go language support. Worse, the code it produces often <strong>leaves hardcoded keys, connection strings, and other secrets sitting in your function for you to clean up later<\/strong>, picks patterns that don&#8217;t scale (client-per-invocation, blocking I\/O on the hot path), and skips identity-based access entirely. The code compiles, but it isn&#8217;t secure, isn&#8217;t current, and isn&#8217;t using what Azure Functions offers today.<\/p>\n<p><code>azure-functions-skills<\/code> closes that gap. The skills steer the agent toward managed identity, Key Vault references, Flex Consumption, and the binding and concurrency patterns that scale \u2014 and the built-in <code>doctor<\/code> catches the rest before deploy.<\/p>\n<p><strong>Try it now:<\/strong> <a href=\"https:\/\/github.com\/Azure\/azure-functions-skills\"><code>npx @azure\/functions-skills install<\/code><\/a><\/p>\n<p><em>In about 5 minutes you&#8217;ll have a working Functions project scaffolded with managed identity, a deploy-ready workflow, and a <code>doctor<\/code> HTML report you can wire into CI.<\/em><\/p>\n<p><em>Requirements: Node 18+, an Azure subscription, and one of: GitHub Copilot CLI, Claude Code, Codex CLI, or VS Code.<\/em><\/p>\n<blockquote><p><strong>Availability:<\/strong> <code>azure-functions-skills<\/code> is in <strong>public preview<\/strong> on npm as <code>@azure\/functions-skills<\/code> and on the GitHub Copilot CLI \/ Claude Code \/ Codex plugin marketplaces. The skill set is intentionally small at launch and will grow with each Azure Functions release.<\/p><\/blockquote>\n<h2>What is azure-functions-skills?<\/h2>\n<p><code>azure-functions-skills<\/code> is a plugin for AI coding agents. It builds on the broader <a href=\"https:\/\/github.com\/microsoft\/azure-skills\"><code>azure-skills<\/code><\/a> plugin for cross-Azure scenarios, and it ships:<\/p>\n<ul>\n<li><strong>Skills.<\/strong> Task-focused playbooks the agent loads on demand (<code>setup<\/code>, <code>create<\/code>, <code>deploy<\/code>, <code>diagnostics<\/code>, <code>best-practices<\/code>, <code>health-status<\/code>, <code>inventory<\/code>, <code>doctor<\/code>, <code>feedback<\/code>).<\/li>\n<li><strong>An agent definition<\/strong> (<code>functions-copilot<\/code>) that routes user requests to the right skill and proposes the next workflow when one finishes.<\/li>\n<li><strong>MCP server configuration<\/strong>, <strong>hooks<\/strong>, and <strong>instruction files<\/strong> (<code>copilot-instructions.md<\/code>, <code>CLAUDE.md<\/code>, <code>AGENTS.md<\/code>). Everything the agent needs to behave consistently across hosts.<\/li>\n<li><strong>A companion CLI, <code>@azure\/functions-skills<\/code><\/strong>, that installs all of the above with one command, lets you run the agent (<code>chat<\/code>), and validates your project before deployment (<code>doctor<\/code>).<\/li>\n<\/ul>\n<blockquote><p><strong>Names you&#8217;ll see in this post:<\/strong>\n<code>@azure\/functions-skills<\/code> \u2014 the npm package and CLI you run.\n<code>azure-functions-skills<\/code> \u2014 the plugin (skills + instructions) the CLI installs.\n<code>functions-copilot<\/code> \u2014 the agent definition that routes you to the right skill.<\/p><\/blockquote>\n<p>Two design choices shape every feature:<\/p>\n<ol>\n<li><strong>Skill discovery is a first-class product surface.<\/strong> Skill names and granularity are tuned so the agent picks the right one at the moment a developer asks for it, and so a developer browsing the catalog can recognize what each skill is for. Where a request belongs to the broader Azure surface, we route into the <a href=\"https:\/\/github.com\/microsoft\/azure-skills\"><code>azure-skills<\/code><\/a> plugin rather than reinvent it.<\/li>\n<li><strong>The agent responds in the language you write in.<\/strong> Ask in Japanese, get Japanese. Ask in English, get English. The instruction files are wired so the host agent honors the conversation language consistently.<\/li>\n<\/ol>\n<h2>What ships in the preview<\/h2>\n<h3>Skill catalog<\/h3>\n<blockquote><p>The <code>azure-functions-agents<\/code> skill is included from launch and supports the <strong>Azure Functions serverless agents runtime<\/strong> that just launched at Build 2026.<\/p><\/blockquote>\n<table>\n<thead>\n<tr>\n<th>Skill<\/th>\n<th>What it does<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td><code>azure-functions-setup<\/code><\/td>\n<td>Detects Azure CLI \/ <code>azd<\/code> \/ Core Tools \/ language runtimes \/ the <code>azure-skills<\/code> plugin on your machine and walks you through installing what&#8217;s missing.<\/td>\n<\/tr>\n<tr>\n<td><code>azure-functions-create<\/code><\/td>\n<td>Scaffolds new Functions projects, or adds functions to an existing project, using the <strong>Azure MCP<\/strong> template service so you always start from the latest templates.<\/td>\n<\/tr>\n<tr>\n<td><code>azure-functions-agents<\/code><\/td>\n<td>\ud83d\ude80 Scaffolds, extends, deploys, and troubleshoots event-driven AI agents on the <strong>Azure Functions serverless agents runtime<\/strong> (<code>azurefunctions-agents-runtime<\/code>) that just launched at Build 2026. Picks the best deployable GPT model based on subscription \/ region quota, wires Microsoft Foundry, Connector Namespaces, and remote MCP servers, and offloads code execution or web browsing to Azure Container Apps dynamic sessions.<\/td>\n<\/tr>\n<tr>\n<td><code>azure-functions-deploy<\/code><\/td>\n<td>Hands off to the <code>azure-skills<\/code> <code>prepare<\/code> \u2192 <code>validate<\/code> \u2192 <code>deploy<\/code> workflow with Functions-specific guidance (Flex Consumption, <code>functionAppConfig<\/code>, private networking, identity).<\/td>\n<\/tr>\n<tr>\n<td><code>azure-functions-best-practices<\/code><\/td>\n<td>Reviews an existing Function App against current best practices and proposes prioritized, approval-gated remediations.<\/td>\n<\/tr>\n<tr>\n<td><code>azure-functions-diagnostics<\/code><\/td>\n<td>Investigates deployment failures, runtime errors, trigger \/ binding issues, and logging gaps.<\/td>\n<\/tr>\n<tr>\n<td><code>azure-functions-health-status<\/code><\/td>\n<td>Collects the current running state, metrics, Application Insights signals, Resource Health, and Activity Log.<\/td>\n<\/tr>\n<tr>\n<td><code>azure-functions-inventory<\/code><\/td>\n<td>Collects static specifications: SKU, runtime, networking, identity, settings, functions, and trigger inventory.<\/td>\n<\/tr>\n<tr>\n<td><code>azure-functions-doctor<\/code><\/td>\n<td>Pre-deployment validation, used by the <code>doctor<\/code> CLI command below.<\/td>\n<\/tr>\n<tr>\n<td><code>azure-functions-feedback<\/code><\/td>\n<td>Turns observations from a session into a previewed GitHub issue or PR against this repo.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p>The set is intentionally small at launch. It already includes <code>azure-functions-agents<\/code> so you can scaffold and deploy on the <strong>Azure Functions serverless agents runtime<\/strong> that just launched at Build 2026. A skill to assist <strong>migrating worker code to Go<\/strong> is next.<\/p>\n<blockquote><p>Have a skill you&#8217;d like to see? Open an issue at <a href=\"https:\/\/github.com\/Azure\/azure-functions-skills\/issues\">https:\/\/github.com\/Azure\/azure-functions-skills\/issues<\/a>, or just run <code>azure-functions-feedback<\/code> mid-session and the skill itself will prepare the issue draft for you.<\/p><\/blockquote>\n<h2>The CLI: install, chat, doctor<\/h2>\n<h3>install: one command for every host<\/h3>\n<p>Each AI coding agent has its own plugin install flow, and several of them spread the work across multiple steps. The GitHub Copilot CLI plugin, in particular, can only be installed at user scope. That&#8217;s useful for skills, but <strong>not<\/strong> what you want for project-specific MCP servers, hooks, or instruction files that should live with your repository.<\/p>\n<p><code>install<\/code> collapses all of that into one command and applies the right split by default:<\/p>\n<ul>\n<li><strong>Plugin (skills) \u2192 user scope.<\/strong> Available to every project on your machine.<\/li>\n<li><strong>Workspace artifacts (MCP, agent definition, hooks, <code>CLAUDE.md<\/code> \/ <code>AGENTS.md<\/code>) \u2192 the current directory.<\/strong> Committable alongside your code.<\/li>\n<\/ul>\n<p>This keeps your user-scope agent context clean and makes the Azure Functions skills <strong>findable<\/strong> every time you open the workspace. If you want everything in the project, add <code>--local<\/code>:<\/p>\n<pre><code class=\"language-bash\"># GitHub Copilot CLI (default: plugin user-scope, workspace artifacts here)\r\nnpx @azure\/functions-skills install --agent ghcp\r\n\r\n# Everything in the project\r\nnpx @azure\/functions-skills install --agent ghcp --local<\/code><\/pre>\n<p>Use <code>--agent claude<\/code> for Claude Code or <code>--agent codex<\/code> for Codex CLI. The CLI also absorbs future plugin-flow changes so the command stays stable for users.<\/p>\n<h3>chat: start the agent with the right context<\/h3>\n<p><code>chat<\/code> launches your installed agent of choice, already wired into the <code>functions-copilot<\/code> agent definition.<\/p>\n<pre><code class=\"language-bash\">npx @azure\/functions-skills chat<\/code><\/pre>\n<p>A typical first message looks like this:<\/p>\n<blockquote><p><em>&#8220;Create a Python HTTP trigger that reads from Cosmos DB using managed identity, and add a Service Bus output binding.&#8221;<\/em><\/p><\/blockquote>\n<p>The agent picks the right skills (<code>create<\/code>, then <code>best-practices<\/code>), uses the Azure MCP template service for the latest scaffold, and wires identity-based access by default. No keys in your repo.<\/p>\n<p>The first time you run <code>chat<\/code> in a workspace, the <strong><code>setup<\/code> skill auto-fires<\/strong>. It walks through prerequisites (Azure CLI, Azure Developer CLI, Core Tools, language runtimes, the <code>azure-skills<\/code> plugin) and offers to install anything missing, so a developer brand-new to Azure Functions can get to a working environment without bouncing between docs.<\/p>\n<p>After setup, the agent suggests the most useful next skill based on your project state, which makes the rest of the catalog easy to discover.<\/p>\n<p><img decoding=\"async\" src=\"https:\/\/devblogs.microsoft.com\/azure-sdk\/wp-content\/uploads\/sites\/58\/2026\/06\/06-12-introducing-azure-functions-skills-chat.webp\" alt=\"chat launches the functions-copilot agent; on first run, the setup skill auto-fires to verify prerequisites\" \/><\/p>\n<p>Everything after <code>--<\/code> is passed through to the underlying agent, so any agent-native flag you rely on still works. Subsequent <code>chat<\/code> runs skip setup because the per-workspace state lives under <code>.azure-functions-skills\/<\/code>.<\/p>\n<p>VS Code users get the same experience: open the workspace, pick the <code>functions-copilot<\/code> agent, and run the <code>setup<\/code> skill from there.<\/p>\n<p><img decoding=\"async\" src=\"https:\/\/devblogs.microsoft.com\/azure-sdk\/wp-content\/uploads\/sites\/58\/2026\/06\/06-12-introducing-azure-functions-skills-vscode.webp\" alt=\"Selecting the functions-copilot custom agent from the GitHub Copilot Chat agent picker in VS Code\" \/><\/p>\n<h3>doctor: shift-left for the two biggest incident causes<\/h3>\n<p>Do you know the top two causes of Azure Functions support incidents reported to our team?<\/p>\n<ol>\n<li><strong>User code defects<\/strong><\/li>\n<li><strong>Function App misconfiguration<\/strong><\/li>\n<\/ol>\n<p>Together, they account for <strong>roughly half of the Azure Functions support incidents<\/strong> we see internally \u2014 based on our analysis of Customer Reported Incidents (CRIs) in Q1 CY2026, <strong>about 53% were related to customer code or configuration issues<\/strong>. Preventing this class of issue before deploy time eliminates a large fraction of the problems customers report.<\/p>\n<p><code>doctor<\/code> checks a workspace for exactly those issues. It runs in two tiers:<\/p>\n<ul>\n<li><strong>Tier 1 (deterministic, no LLM):<\/strong> <code>host.json<\/code> shape, runtime version, trigger configuration, extension bundle range, deprecated settings, lockfile presence, tracked <code>.env<\/code> files, and a set of <strong>supply-chain checks<\/strong> (lifecycle scripts, unpinned production dependencies, install-script dependencies, and more) informed by the recent npm \/ PyPI compromises.<\/li>\n<li><strong>Tier 2 (semantic, LLM via <code>--deep<\/code>):<\/strong> Uses your coding agent to find issues that need to <em>read<\/em> the code: client-per-invocation patterns, blocking I\/O on the hot path, hardcoded secrets, Durable Functions non-determinism (<code>Date.now()<\/code>, <code>Math.random()<\/code>, network calls in orchestrators), credential collection patterns, and more.<\/li>\n<\/ul>\n<p>Run it locally and get a self-contained HTML report (the <code>--deep --accept-deep-risk<\/code> flags opt into Tier 2 LLM checks; safe to run locally, see the CI note below before using in pipelines):<\/p>\n<pre><code class=\"language-bash\">npx @azure\/functions-skills doctor --dir . \\\r\n  --deep --accept-deep-risk \\\r\n  --agent github-copilot \\\r\n  --format html --output doctor-report.html<\/code><\/pre>\n<p>A representative run looks like this:<\/p>\n<pre><code class=\"language-text\">Tier 1 (deterministic)\r\n  \u2713 host.json shape ok\r\n  \u2713 runtime version pinned (~4)\r\n  \u26a0 extension bundle range too broad   host.json:5\r\n  \u26a0 unpinned production dependency      semver:^7.0.0 \u2192 pin to 7.5.4\r\n  \u2717 tracked .env file with secret keys  .env:3\r\n\r\nTier 2 (semantic, via --deep)\r\n  \u26a0 blocking I\/O on hot path            app\/orders.py:42  (use async client)\r\n  \u2717 hardcoded connection string         app\/cosmos.py:11  (use Key Vault reference)\r\n  \u26a0 client-per-invocation pattern       app\/blob.py:18    (hoist client to module scope)\r\n\r\nSummary: 2 critical, 4 warnings \u2014 see doctor-report.html<\/code><\/pre>\n<p><img decoding=\"async\" src=\"https:\/\/devblogs.microsoft.com\/azure-sdk\/wp-content\/uploads\/sites\/58\/2026\/06\/06-12-introducing-azure-functions-skills-doctor-report.webp\" alt=\"Doctor HTML report showing Tier 1 host.json and dependency findings plus Tier 2 semantic findings from the coding agent\" \/><\/p>\n<p>The same command can run in CI. Wire it into your deployment pipeline and you have <strong>shift-left<\/strong> for the configuration and code-quality issues that drive the majority of incidents, caught while the developer (or the agent acting for them) can still fix the diff cheaply.<\/p>\n<h4>A word on running &#8211;deep in CI<\/h4>\n<p><code>--deep<\/code> runs the coding agent with file-write and shell-execution permissions, so any input the agent sees becomes a potential prompt-injection surface. We default to refusing <code>--deep<\/code> on <code>pull_request<\/code> events. You can opt in with <code>AZURE_FUNCTIONS_DOCTOR_TRUST_PR=1<\/code> for trusted mirror pipelines.<\/p>\n<p>The recommended pattern:<\/p>\n<ul>\n<li><strong>PR validation:<\/strong> <code>--no-deep<\/code> (Tier 1 only). Fast, deterministic, safe to run on untrusted PR content.<\/li>\n<li><strong>Post-merge \/ release:<\/strong> <code>--deep<\/code> on <code>push: main<\/code>, ideally gated behind a <a href=\"https:\/\/docs.github.com\/en\/actions\/deployment\/targeting-different-environments\/using-environments-for-deployment\">GitHub Environment<\/a> with required reviewers and a scoped secret for the agent token.<\/li>\n<\/ul>\n<p>See <a href=\"https:\/\/github.com\/Azure\/azure-functions-skills\/blob\/main\/docs\/doctor-guide.md\"><code>docs\/doctor-guide.md<\/code><\/a> and <a href=\"https:\/\/github.com\/Azure\/azure-functions-skills\/blob\/main\/SECURITY.md\"><code>SECURITY.md<\/code><\/a> for the full security model.<\/p>\n<h2>Where each skill fits<\/h2>\n<table>\n<thead>\n<tr>\n<th>When you want to&#8230;<\/th>\n<th>Use<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td>Get your local environment ready for Functions development<\/td>\n<td><code>azure-functions-setup<\/code><\/td>\n<\/tr>\n<tr>\n<td>Start a new project or add a function<\/td>\n<td><code>azure-functions-create<\/code><\/td>\n<\/tr>\n<tr>\n<td>Build a scheduled or event-driven AI agent (daily briefing, inbox digest, connector-triggered workflow)<\/td>\n<td><code>azure-functions-agents<\/code><\/td>\n<\/tr>\n<tr>\n<td>Deploy to Azure<\/td>\n<td><code>azure-functions-deploy<\/code><\/td>\n<\/tr>\n<tr>\n<td>Catch problems before deployment<\/td>\n<td><code>doctor<\/code> CLI (or <code>azure-functions-doctor<\/code>)<\/td>\n<\/tr>\n<tr>\n<td>Review an existing app against current best practices<\/td>\n<td><code>azure-functions-best-practices<\/code><\/td>\n<\/tr>\n<tr>\n<td>Investigate a failing or misbehaving Function App<\/td>\n<td><code>azure-functions-diagnostics<\/code><\/td>\n<\/tr>\n<tr>\n<td>Check the live health of a running app<\/td>\n<td><code>azure-functions-health-status<\/code><\/td>\n<\/tr>\n<tr>\n<td>Send us feedback or a feature request<\/td>\n<td><code>azure-functions-feedback<\/code><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p><code>functions-copilot<\/code> routes your request to the appropriate skill, and proposes the next step after each workflow.<\/p>\n<h2>Getting started<\/h2>\n<p>Pick the agent you already use; the rest of the flow is the same.<\/p>\n<pre><code class=\"language-bash\"># 1. Install the plugin (default: skills at user scope, workspace artifacts here)\r\nnpx @azure\/functions-skills install --agent ghcp     # GitHub Copilot CLI\r\nnpx @azure\/functions-skills install --agent claude   # Claude Code\r\nnpx @azure\/functions-skills install --agent codex    # Codex CLI\r\n\r\n# 2. Launch the agent (setup skill auto-fires on first run)\r\nnpx @azure\/functions-skills chat\r\n\r\n# 3. Validate before deploy (--deep enables Tier 2 LLM checks; safe locally, see CI note)\r\nnpx @azure\/functions-skills doctor --deep --accept-deep-risk \\\r\n  --agent github-copilot \\\r\n  --format html --output doctor-report.html<\/code><\/pre>\n<p><strong>VS Code:<\/strong> after step 1, open the workspace in VS Code, select the <code>functions-copilot<\/code> agent in GitHub Copilot Chat, and run the <code>setup<\/code> skill. Same first-run experience as <code>chat<\/code>, just inside the IDE.<\/p>\n<blockquote><p>Prefer the skills scoped to the current project only? Add <code>--local<\/code> to step 1.<\/p><\/blockquote>\n<p>Full docs, CI recipes, and the supply-chain check reference live at <a href=\"https:\/\/github.com\/Azure\/azure-functions-skills\">https:\/\/github.com\/Azure\/azure-functions-skills<\/a>.<\/p>\n<h2>We want your feedback<\/h2>\n<p><code>azure-functions-skills<\/code> is open source, MIT licensed, and developed in the open. The repository is the right place to:<\/p>\n<ul>\n<li><strong>Ask for skills you wish were there:<\/strong> open an issue, or run <code>azure-functions-feedback<\/code> mid-session and have the skill prepare the draft for you.<\/li>\n<li><strong>Report bugs or suggest improvements.<\/strong> Every issue is read.<\/li>\n<li><strong>Contribute a skill or doc.<\/strong> See <a href=\"https:\/\/github.com\/Azure\/azure-functions-skills\/blob\/main\/CONTRIBUTING.md\"><code>CONTRIBUTING.md<\/code><\/a>.<\/li>\n<\/ul>\n<p>Repository: <strong><a href=\"https:\/\/github.com\/Azure\/azure-functions-skills\">https:\/\/github.com\/Azure\/azure-functions-skills<\/a><\/strong><\/p>\n<p>We&#8217;re building the AI-era developer experience for Azure Functions in the open. <strong>Star the repo<\/strong>, <strong>open an issue<\/strong>, or run <code>azure-functions-feedback<\/code> mid-session and have the skill draft the issue for you. Tell us what to ship next.<\/p>\n","protected":false},"excerpt":{"rendered":"<p>azure-functions-skills gives GitHub Copilot CLI, Claude Code, Codex CLI, and VS Code the skills, MCP configuration, hooks, and instructions needed to create, diagnose, deploy, and validate Azure Functions projects end-to-end.<\/p>\n","protected":false},"author":214410,"featured_media":3874,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[1],"tags":[941,786,734,765,977,986,987,972,940,959,960],"class_list":["post-3870","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-azure-sdk","tag-agents","tag-ai","tag-azure","tag-azure-functions","tag-claude","tag-codex","tag-developer-tools","tag-github-copilot","tag-mcp","tag-model-context-protocol","tag-serverless"],"acf":[],"blog_post_summary":"<p>azure-functions-skills gives GitHub Copilot CLI, Claude Code, Codex CLI, and VS Code the skills, MCP configuration, hooks, and instructions needed to create, diagnose, deploy, and validate Azure Functions projects end-to-end.<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/azure-sdk\/wp-json\/wp\/v2\/posts\/3870","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/devblogs.microsoft.com\/azure-sdk\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/devblogs.microsoft.com\/azure-sdk\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/azure-sdk\/wp-json\/wp\/v2\/users\/214410"}],"replies":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/azure-sdk\/wp-json\/wp\/v2\/comments?post=3870"}],"version-history":[{"count":1,"href":"https:\/\/devblogs.microsoft.com\/azure-sdk\/wp-json\/wp\/v2\/posts\/3870\/revisions"}],"predecessor-version":[{"id":3875,"href":"https:\/\/devblogs.microsoft.com\/azure-sdk\/wp-json\/wp\/v2\/posts\/3870\/revisions\/3875"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/azure-sdk\/wp-json\/wp\/v2\/media\/3874"}],"wp:attachment":[{"href":"https:\/\/devblogs.microsoft.com\/azure-sdk\/wp-json\/wp\/v2\/media?parent=3870"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/azure-sdk\/wp-json\/wp\/v2\/categories?post=3870"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/azure-sdk\/wp-json\/wp\/v2\/tags?post=3870"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}