Skills Registry

Analyzes Azure infrastructure and usage data to identify cost-saving opportunities and organize implementation through GitHub.

Designs Azure infrastructure from natural-language requirements or analyzes existing resources, then supports architecture refinement and Bicep-based deployment.

Validates Bicep deployments before execution by checking template syntax, previewing Azure resource changes, and assessing deployment permissions.

Provides Azure CLI command guidance for managing Azure DevOps projects, repositories, pipelines, work items, and related services.

Fetches current Azure retail prices and turns them into cost estimates, including Copilot Studio credit usage.

Assess an Azure resource’s operational health, use its logs and telemetry to investigate issues, and recommend prioritized remediation.

Maps Azure resource-group resources and their verified connections into a clear architecture view.

It maps requested Azure permissions to the least-privilege built-in role, or a custom role if no built-in role matches.

It explains how to configure and deploy static frontends on Azure, with local emulation and optional serverless APIs.

Navigate and interact with Chrome while examining page structure, browser diagnostics, and performance behavior.

Shape a computational aesthetic into a reproducible artwork whose visual character emerges from rules, seeded variation, and evolving behavior.

Applies Anthropic’s visual identity to artifacts with its color palette, typography, and consistent text hierarchy.

Shapes a visual philosophy and turns it into original, design-led artwork with minimal text.

Reference for the Claude API / Anthropic SDK — model ids, pricing, params, streaming, tool use, MCP, agents, caching, token counting, model migration. TRIGGER — read BEFORE opening the target file; don't skip because it "looks like a one-liner" — whenever: the prompt names Claude/Anthropic in any form (Claude, Anthropic, Fable, Opus, Sonnet, Haiku, `anthropic`, `@anthropic-ai`, `claude-*`, `us.anthropic.*`, `[1m]`); the user asks about an LLM (pricing/model choice/limits/caching) — never answer from memory; OR the task is LLM-shaped with provider unstated (agent/MCP/tool-definition/multi-agent/RAG/LLM-judge/computer-use; generate/summarize/extract/classify/rewrite/converse over NL; debugging refusals/cutoffs/streaming/tool-calls/tokens). SKIP only when another provider is being worked on (overrides all triggers): OpenAI/GPT/Gemini/Llama/Mistral/Cohere/Ollama named in the query; OR `grep -rE 'openai|langchain_openai|google.generativeai|genai|mistralai|cohere|ollama'` over the project hits (run this grep FIRST if no provider named — don't Read the file).

It guides collaborative document creation through context gathering, section-by-section refinement, and reader testing.

Develops an interface direction grounded in its subject, with deliberate visual hierarchy, typography, motion, and user-facing language.

It provides guidance for writing internal messages in the formats preferred by the company.

Guide the end-to-end design, implementation, review, testing, and evaluation of MCP servers that let LLMs interact with external services through well-designed tools.

Helps shape, draft, test, and iteratively improve agent skills based on observed results.

Provides guidance and utilities for building and optimizing animated GIFs for Slack.

Helps create a coherent visual identity by applying coordinated colors and fonts to presentations and other artifacts.

Build and package frontend artifacts for Claude conversations using a configured React and TypeScript toolchain.

Automate browser checks of local web applications with Python Playwright scripts.

Build, debug, or review Cloudflare Agents SDK applications using the agents package.

Discover and choose Cloudflare products for apps, APIs, AI agents, storage, networking, and security. Use for architecture and product selection, including when the user describes a need without naming a Cloudflare product; then find the relevant skill or documentation.

Implement or troubleshoot Cloudflare Email Sending and Email Routing integrations and their delivery configuration.

Design, configure, troubleshoot, or review Cloudflare One Zero Trust and SASE deployments. Use cloudflare-one-migrations for migration planning from other vendors.

Assess and plan migrations from existing VPN, SWG, or SASE platforms to Cloudflare One, including policy mapping, parity gaps, and rollout.

Build, debug, or review Cloudflare Durable Objects code for persistent state and coordination.

Migrate Cloudflare Sandbox apps from stable @cloudflare/sandbox to @cloudflare/sandbox@next (SDK 1.0 preview). Use sandbox-next for apps already on the preview.

Build or maintain Cloudflare Sandbox apps on @cloudflare/sandbox@next (SDK 1.0 preview). Use sandbox-migrate-to-next when porting a stable app.

Build or maintain Cloudflare Sandbox apps on the stable @cloudflare/sandbox package. Use sandbox-next for preview apps and sandbox-migrate-to-next for stable-to-preview migrations.

Set up, repair, or migrate to Cloudflare Turnstile bot verification in an existing frontend and backend, including server-side Siteverify.

Provides a measurement-led workflow for examining browser traces, network behavior, and available source code to prioritize concrete performance improvements.

Cloudflare Workers best practices for production applications. Use when writing, reviewing, or configuring Workers.

Run or troubleshoot Wrangler CLI commands and configure Worker projects for local development, Previews, deployment, and Cloudflare resource management.

Guides the design and review of C# asynchronous code, with attention to task usage, exception propagation, and efficient concurrency.

Establishes conventions for XML documentation that clearly explains C# API behavior and usage.

Builds a C# Model Context Protocol server project using host-based dependency injection and stdio transport, with discoverable tools and practical operating guidance.

Provides practical guidance for structuring MSTest 3.x/4.x unit tests, using current assertions, lifecycle hooks, and data-driven testing features.

Helps build reliable NUnit unit tests with clear structure, focused assertions, and suitable test data.

Helps build clear, reliable TUnit tests using consistent structure, lifecycle hooks, assertions, and data-driven patterns.

It explains conventions for structuring, organizing, and verifying xUnit unit tests, including assertions, shared test context, isolation, and categorization.

Helps align .NET/C# code with a solution's practices for documentation, architecture, dependency injection, async work, testing, configuration, localization, logging, security, and maintainability.

Assess how a C#/.NET codebase applies design patterns, architectural boundaries, and platform best practices.

Helps choose a safe timezone strategy for .NET applications and turn it into practical implementation guidance.

It organizes .NET solution upgrade work, from project and dependency assessment through code, pipeline, and release validation.

Keeps formatting consistent across a project by translating its file types and stated conventions into editor-wide rules.

Provides practical guidance for structuring EF Core contexts and entities and handling queries, persistence, migrations, security, and tests.

It promotes consistent NuGet dependency management and protects project integrity through restore verification.

Build and submit iOS and Android apps with EAS to TestFlight, the App Store, or Google Play. Supports Expo and other React Native projects, plus existing native apps. Use for eas.json setup, release pipelines, signing, app versions and build numbers, store submissions, and listing metadata. For Expo websites and API routes, use eas-hosting; for adding React Native screens to a native app, use expo-brownfield.

Deploy Expo websites and Expo Router API routes to EAS Hosting - export the web bundle, run eas deploy for production and PR preview URLs, manage environment secrets and custom domains, and work within the Cloudflare Workers runtime. Also covers authoring API routes (+api.ts handlers, HTTP methods, request handling, CORS). Use when deploying an Expo web app or API routes, setting up EAS Hosting, or configuring hosting environments and domains. Not for native builds or store releases - use the eas-app-stores skill for those.

Use for anything related to EAS Observe - adding `expo-observe` to an Expo project (AppMetricsRoot/ObserveRoot HOC, markInteractive and ObserveInteractiveMarker, the useObserve hook, the Expo Router / React Navigation integrations for per-route metrics, user-defined events via `Observe.logEvent`, error reporting via ObserveErrorBoundary and `Observe.reportError`, and runtime config such as sampleRate and dispatchInDebug), querying via the EAS CLI (`eas observe:metrics-summary`, `observe:metrics`, `observe:routes`, `observe:events`, `observe:session`, `observe:versions`), interpreting the resulting metrics (cold/warm launch, TTR, TTI, navigation cold/warm TTR, update download, and the TTI frameRate/device/network params for triaging slow startups), or shipping an Observe integration inside a third-party package.

Run and control a user's app on a remote iOS/Android simulator hosted on EAS cloud. Read before running any `eas simulator:*` commands - it has the current syntax for this experimental API. Use whenever the user needs a simulator they can't run locally - 'run my app on a cloud simulator', 'use eas simulator to run/install/screenshot my app', 'I'm on Linux/Cursor and need an iOS device', 'no sim on this box / headless CI', 'let an agent click through my app and screenshot it', 'test my dev build on a remote sim with live reload', 'stream a sim to my browser' - even when they don't say 'EAS Simulator' or 'cloud'. On a host WITHOUT a local simulator (Linux, CI, cloud sandbox) it's the default; on macOS, do NOT auto-trigger for a plain 'run on the simulator' - use it only for a cloud/remote/shareable sim, an iOS version they lack, or an agent-driven session. NOT for local sims (expo run:ios, Xcode, Android Studio), EAS Build/Update, web preview, or physical devices.

Configure and use EAS Update for over-the-air JavaScript and asset updates with expo-updates and EAS CLI. Use when setting up OTA updates, running eas update:configure or eas update, publishing to preview/staging/production channels, explaining branches/channels/runtime versions, testing updates, or debugging why an installed build still shows old code. Load for TestFlight, preview, or production updates that do not appear, including questions about cold launches or reopening the app. Not for update health metrics; use eas-update-insights for adoption, crashes, and rollout monitoring.

Check the health of published EAS Update: crash rates, install/launch counts, unique users, payload size, and the split between embedded and OTA users per channel. Use when the user asks how an update is performing, whether a rollout is healthy, how many users are on the embedded build vs OTA, or wants to gate CI on update health.

Helps understand and write EAS workflow YAML files for Expo projects. Use this skill when the user asks about CI/CD or workflows in an Expo or EAS context, mentions .eas/workflows/, or wants help with EAS build pipelines or deployment automation.

Build animations in React Native and Expo, making the decisions in the order that determines whether they feel right — should it animate, which thread it runs on, which properties, spring or timing, how the gesture hands off, how it degrades. Writes the implementation with Reanimated, Gesture Handler, Expo Router and expo-haptics. Use when animating anything in an Expo app, adding gestures, sheets, screen transitions, press feedback or haptics, or fixing motion that stutters on device. For web animation use `animate`.

Add an iOS App Clip target to an Expo app. Use when the user mentions App Clip, AASA, apple-app-site-association, appclips, smart app banner, or wants to ship a lightweight iOS Clip invoked from a URL alongside their parent app.

Integrate Expo and React Native into an existing native iOS or Android app. Use for brownfield, embedding a React Native screen in SwiftUI/UIKit or Kotlin, or AAR/XCFramework packaging. Covers isolated and integrated approaches. For building or distributing a purely native app with EAS, use eas-app-stores.

Use when implementing or debugging ANY network request, API call, or data fetching. Covers fetch API, React Query, SWR, error handling, caching, offline support, loading/empty/error screen states, and Expo Router data loaders (`useLoaderData`).

Build and maintain a design system inside an Expo app - a reusable theme of design tokens (color, spacing, typography, radius, shadow, motion), reusable component structure with variant/size/state prop conventions, and rules for when to extract a repeated view into a shared component. Use when creating or organizing theme files and design tokens (theme.ts / theme/), extending an existing theme or styling library (NativeWind, Tamagui, Restyle, Unistyles) in its own idiom, standardizing styles so screens (including AI-generated ones) look consistent and polished, fixing an app that looks AI-generated or generic instead of native (the named native-slop tells), building an in-app component library, or auditing an app for design-system drift (hardcoded colors, spacing, fonts). For platform styling specifics (semantic colors, HIG rules, native controls) use expo-native-ui; for folder layout of a new app use expo-project-structure.

Build and distribute Expo development clients locally or via TestFlight for internal testing. For production TestFlight releases and store submission, use the eas-app-stores skill.

Use Expo DOM components to run web code in a webview on native and as-is on web. Migrate web code to native incrementally. For the end-to-end migration of a whole web app, use the expo-web-to-native skill.

Expo's official example projects - the expo/examples repo of ~70 `with-*` integrations (Stripe, Clerk, Supabase, OpenAI, maps, Reanimated, SQLite, Skia, NativeWind, and more). Use when integrating a third-party library or service into an existing Expo app and you want the canonical, version-matched pattern to adapt, or when scaffolding a new project from one with `npx create-expo --example`.

Guide for creating and writing Expo native modules and views using the Expo Modules API (Swift, Kotlin, TypeScript). Covers module definition DSL, native views, shared objects, config plugins, lifecycle hooks, autolinking, and type system. Use when building or modifying native modules for Expo. Not for migrating an existing Swift module from the definition DSL to the Expo Modules API 2.0 macros; use expo-migrate-module (from the expo-experiments plugin) for that.

Build beautiful, native-feeling Expo screens. Covers Apple HIG styling, semantic colors, native controls, SF Symbols, media, visual effects, gradients, storage, and responsive layout. For routing and navigation, use the expo-router skill; for motion and animation, use the expo-animation skill.

Entry point and router for every Expo or EAS task. Load this skill first — before writing code and before choosing another expo-* / eas-* skill — when the request, PRD, or spec mentions Expo, EAS, Expo Go, or an expo-* package, or the project has an `expo` dependency in `package.json`. Within that gate it also covers app specs and designs to implement (tabs, stacks, maps, lists, navigation, building from a screenshot), and phrasings like 'implement a mobile app', 'make my app look native', 'add navigation', 'fetch some data', 'upgrade my SDK', 'add Expo to my existing native app', 'ship to the App Store', or 'I'm new to Expo, where do I start'. A fully specified request (SDK pinned, libraries named, layout given) still routes through here — the shared setup rules still apply. Do NOT load it when neither signal is present: a bare React Native project with no `expo` dependency is not Expo work. Detects the real goal, routes to the right expo-* / eas-* skill, and owns the shared setup rules.

Folder structure for a new Expo app. Use when scaffolding or laying out a new Expo project with Expo Router, or deciding where a file should live in one. For new projects only — never restructure an existing app to match.

Navigation and routing for Expo Router. Covers file-based routes, groups and dynamic routes, folder organization, Link with previews and context menus, native Stack, page titles, modals and form sheets, NativeTabs, headers and toolbars, and header search bars.

Helps users share actionable feedback about Expo and manage its separate, opt-in usage telemetry.

Build native UI with the @expo/ui package: real SwiftUI on iOS and Jetpack Compose on Android. Default to @expo/ui for sheets (BottomSheet), pickers, sliders, toggles, menus, and grouped-form sections — do NOT reach for Reanimated, @gorhom/bottom-sheet, or RN built-in Picker/Switch; use @expo/ui instead. Fall back to RN built-ins only when @expo/ui is missing the component. NOTE: @expo/ui List renders native grouped rows like an iOS Settings screen — it is NOT a virtualized list; use FlatList/FlashList for large datasets. Covers universal components (Host, Column, Row, Button, Text, List, BottomSheet, FieldGroup, Switch, Slider, Picker, Menu), drop-in replacements for RN community libraries, and platform-specific SwiftUI/Jetpack Compose trees. Not for Expo Router navigation, Reanimated, or data fetching.

Guidelines for upgrading Expo SDK versions and fixing dependency issues

Migrate an existing web React app to a native iOS/Android app with Expo. Use when the user wants to turn a website into a mobile app, port a Next.js/Vite/CRA React codebase to React Native, reuse web code on native incrementally, or asks how web idioms (the DOM, CSS, React Router, localStorage, window) map to native. This is the end-to-end migration guide; use the `expo-dom` skill for the DOM-component mechanism itself.

Guides end-to-end CodeQL scanning, from choosing languages and build modes to configuring queries and handling results.

It uses the repository's pull request template to turn a specification into one complete pull request with a clear title and body.

Explains how to configure Dependabot to keep dependencies current and address known vulnerabilities across repository ecosystems.

Helps you use GitHub CLI commands and options to manage GitHub work from a terminal.

Classifies current Git changes under Git Flow and names a branch that reflects their purpose.

Supports coordinated GitHub issue management, from issue details to categorization, ownership, and related work.

Turns PlantUML descriptions into readable plain-text diagrams using ASCII or Unicode box-drawing characters.

It streamlines preparing site files, creating a GitHub repository, and configuring Pages so supported content can be served online.

Explains how to configure GitHub secret scanning and push protection, create custom secret patterns, and manage detected-secret alerts.

It organizes the steps for configuring and executing audience-member changes with the Data Manager API, then checking their processing results.

It helps developers build and troubleshoot event-ingestion integrations for Google Ads, Google Analytics, and Floodlight using the Data Manager API.

Explains how to prepare local access to the Data Manager API and install its client and companion utility libraries.

It helps diagnose Google Ads account performance by comparing campaign and ad group data and checking offline conversion uploads.

Explains how to prepare, install, configure, and connect the official Google Ads MCP Server, including local and Cloud Run deployment options.

It explains how to configure Google Ads API authentication and account routing so developers can safely make an initial campaign query.

Guides a consistent SDK migration by aligning Gradle configuration, initialization, format-specific APIs, and callback behavior.

Explains how to place persistent, automatically refreshing rectangular ads in an app layout with the Google Mobile Ads SDK.

Guides a platform-specific setup of the Google Mobile Ads SDK, from adding it to confirming the integration.

It guides the full-screen ad lifecycle and placement at natural transitions between app content.

Describes an opt-in, full-screen ad experience that grants an in-app reward when a user interacts with the ad.

Checks whether a Google Mobile Ads SDK integration meets relevant setup requirements.

Helps developers integrate Google Ad Manager's server-side ad insertion into video apps using its DAI SDK.

It helps integrate Google's IMA SDK to request and manage in-stream video and audio ads in digital products.

It guides you in using the Google Analytics Admin API to inspect accessible account and property summaries and manage supported Analytics settings.

Guides setup and use of the v1beta Data API to enable access, run customized Google Analytics reports, and verify metric and dimension compatibility.

It structures agent alerting around reliability, cost, safety, security, and Vertex AI evaluation quality.

Deploy open models or custom weights from Model Garden to Agent Platform endpoints, check the status of an in-progress deployment operation, or clean up resources by undeploying models and deleting endpoints. Use when asked to actively deploy a model, list the Model Garden CATALOG of available models, check if a specific model is deployable (`gcloud ai model-garden models list-deployment-config`), query deployment cost, troubleshoot deployment errors (like quota limits), or undeploy/clean up endpoints. Also use when copying and deploying a 1P Tuned Model. Don't use for pure listing/discovery questions of the form "is X deployed?", "list my endpoints", or "which regions have models running?" — for those use `agent-platform-endpoint-management`. Don't use for running model evaluations (use `agent-platform-eval-flywheel` skill).

Manages Agent Platform serving endpoints. Use when you need to create, list, describe, update, or delete serving endpoints for model deployment on Agent Platform. Also use when troubleshooting endpoint permission, quota, or resource busy errors. Don't use for deploying models to endpoints or for running model evaluations.

Measures and improves the quality of AI models and agents on Google Cloud using the Eval Quality Flywheel methodology. Use when generating synthetic user scenarios, evaluating an agent or model, building an eval dataset, picking or writing evaluation metrics, analyzing failures, comparing results before and after a fix, or when guidance is needed on Agent Platform eval methodology — including dataset schema, LLM-as-judge scoring, and common failure causes. For fine-tuning, use agent-platform-tuning. For general production deployment, use agent-platform-deploy.

Connects to Google Cloud Agent Platform and supports inference with Gemini, OpenMaaS, and custom-endpoint models.

Explains how to move Gemini API applications from Google AI Studio to Gemini Enterprise Agent Platform, including billing, authentication, and client configuration.

Agent Platform Model Registry Management. Use when you need to upload, list, describe, update, or delete machine learning models (and their versions) in the Agent Platform Model Registry. Don't use for model training, model deployment to endpoints, or managing non-Agent Platform models.

Provides workflows for inspecting managed prompt details, retrieving specific versions, and filling stored templates with input values.

Manage and query Agent Platform RAG Engine Corpora and retrieve grounded contexts using the Google GenAI SDK. Use when listing RAG corpora or files, inspecting a corpus, retrieving contexts, or generating content grounded in a RAG corpus. Do not use for standard database queries (use SQL/Spanner skills), Google Workspace RAG, or other RAG products like gRAG.

Provides ways to discover and manage skills on the Gemini Enterprise Agent Platform, monitor long-running operations, and scaffold new skills locally.

It investigates configuration, authorization, and runtime failures across Agent Gateway, Agent Registry, Agent Identity, policies, IAP-delegated authorization, and service extensions, then reports findings and recommended fixes without applying changes.

Agent Platform Model Tuning. Use when you need to fine-tune open models or Gemini models using Agent Platform infrastructure. Don't use for model training outside Agent Platform, model deployment to endpoints (use `agent-platform-deploy`), or managing serving endpoints (use `agent-platform-endpoint-management`).

Manages GenAI tuning jobs in Agent Platform. Use this to list, get, or cancel ongoing model tuning jobs. Don't use for fine-tuning models (use `agent-platform-tuning`), deploying models to endpoints (use `agent-platform-deploy`), or managing serving endpoints (use `agent-platform-endpoint-management`).

Provides guidance for managing AlloyDB for PostgreSQL resources and using AlloyDB MCP tools to automate database operations.

Guides a local-first Terraform workflow for designing, validating, assessing, importing, deploying, and verifying Google Cloud infrastructure through Application Design Center.

It explains how to use BigQuery’s SQL-based machine learning and generative AI capabilities, including Vertex AI integration, for data analysis.

Guides basic BigQuery setup and the use of SQL to analyze large datasets.

Provides guidance for carrying out data preparation, analysis, visualization, and machine learning with BigQuery-backed DataFrame operations.

Provides data-retrieval best practices, tool selection guidance, and performant SQL query syntax for BigQuery telemetry across INFORMATION_SCHEMA, Cloud Monitoring, and the REST API. Use when the telemetry to fetch is already known, selecting telemetry tools, writing performant INFORMATION_SCHEMA queries, retrieving telemetry for diagnosing single-job performance bottlenecks, investigating slot contention, job concurrency and queue latency, analyzing reservation capacity, utilization and autoscaling saturation, or auditing capacity-based and on-demand compute and storage resource billable usage. Don't use for root-cause diagnosis or symptom troubleshooting when the cause is unknown (use bigquery-troubleshooting first), or for writing or optimizing business logic SQL (use bigquery-optimization).

Provides workflows to optimize BigQuery environments (capacity planning, editions), storage assets (partitioning, clustering, storage lifecycles, billing models), and SQL queries. Use when optimizing cost, modeling Edition migrations, rightsizing reservations, evaluating logical vs. physical storage, designing table partitioning/clustering, generating table DDL, migrating unpartitioned tables, managing partition expiration, optimizing individual SQL queries, or evaluating acceleration structures (search indexes, materialized views, BI Engine). Do not use for raw usage reporting (use bigquery-observability), query execution plan analysis, error troubleshooting, or diagnosing why a specific job was slow (use bigquery-troubleshooting).

Analyzes BigQuery job telemetry to calculate slot hours and query costs and identify performance bottlenecks.

Provides diagnostic workflows and step-by-step root-cause analysis procedures for actively broken, failing, or slow BigQuery jobs, execution graph and query plan stage bottlenecks, system performance issues, or unexpectedly expensive workloads. Use when interpreting symptoms, isolating bottlenecks, diagnosing cost spikes (on-demand query spend, capacity slot autoscaling, storage growth), execution graph stages or substep variables, identifying root causes, and determining remediation steps. Don't use for writing or optimizing SQL, proactive capacity planning, or storage layout design (use bigquery-optimization), or when the user already knows which telemetry they want and just needs the query (use bigquery-observability).

Provides practical guidance for building and operating Google Bigtable systems with efficient data access and careful changes.

Teaches the fundamentals of Cloud Build on Google Cloud. Covers core concepts, API enablement, console navigation to the Build History page, and the end-to-end workflow for creating and manually running a basic build trigger. Do not use for managing private pools or complex pipeline architectures.

Helps translate database requirements into a suitable Google Cloud service choice.

Configure single-project Cloud Logging on Google Cloud: regional log buckets, log sinks, log views, restricting or hiding sensitive logs in the default view (_Default) filter, IAM permissions for views (Logs View Accessor, IAM conditions), logs-based metrics, log exclusions, and sampling. Don't use for cross-project logging or multi-project setups.

Explains how to select between centralized storage and read-time aggregation and outlines the configuration and access controls for each.

Generates Logging Query Language (LQL) queries for Cloud Logging on Google Cloud from natural language. Use this skill when you need to query log data or when you are debugging issues. You can filter log data by Google Cloud service. Don't use this skill to query other databases, such as SQL or Cloud Spanner.

Generates Cloud Monitoring Server-Driven UI (SDUI) Widget and XyChart Protocol Buffer textprotos on Google Cloud from resolved PromQL or ListTimeSeries queries. Use when: - Generating valid google.monitoring.dashboard.v1.Widget textprotos, containing PrometheusQuery or TimeSeriesFilter datasets, for use with the Cloud Monitoring Dashboards API, gcloud CLI, or declarative dashboard definitions. - Synthesizing Server-Driven UI (SDUI) widget titles, axis labels, and plot types for Prometheus or ListTimeSeries queries. Don't use for: - Metric discovery or PromQL query generation. For those tasks, use the cloud-monitoring-metric-selection or cloud-monitoring-promql-query skills.

It translates metric descriptors and resource context into parameters for a Cloud Monitoring time-series query.

Retrieve, query, and identify relevant Cloud Monitoring metric descriptors on Google Cloud for a service or resource (such as Compute Engine, Spanner, BigQuery, Cloud Run, Cloud SQL, Pub/Sub, Cloud Storage, etc.). Use when asked to find, list, search, or discover GCP metric types, names, kind/value schemas, or descriptors.

Translates Cloud Monitoring metric and resource descriptors into valid PromQL, with appropriate metric naming, filtering, and aggregation.

Configures best-practice, high-signal alerting policies for Cloud Run resources on Google Cloud (services, jobs, and worker pools) based on seasoned SRE practices. Use when analyzing, recommending, writing, or deploying Terraform PromQL alerting policies to monitor Cloud Run error rates (4xx/5xx), request latency, container instance saturation (warning/critical), container CPU/memory utilization and allocation, billable instance time, job execution status, and worker pool queue backlog. Don't use for GKE workloads (use gke-alert-configuration) or Compute Engine VMs.

It guides Cloud Run setup and deployment by explaining resource choices, build options, IAM prerequisites, and common failure diagnosis.

Explains how Google Cloud’s managed relational database service runs MySQL, PostgreSQL, and SQL Server workloads while handling maintenance, backups, availability, and secure connectivity.

Analyzes the downstream impact (blast radius) using data lineage on Google Cloud when a BigQuery table or view is broken, stale, or modified. Identifies all downstream tables, dashboards, and processes that will be affected. Use when: - Performing a blast radius or impact analysis for a BigQuery table or view. - Assessing the consequences of modifying, deleting, or pausing updates to a BigQuery asset. - Identifying downstream dependencies (tables, dashboards, processes) of a BigQuery asset. Don't use for: - General BigQuery querying or data analysis (use BigQuery-related tools instead). - Non-BigQuery assets (e.g., Cloud Storage files) unless they are part of the BigQuery lineage. - Creating or modifying lineage links directly.

Summarizes data lineage graphs on Google Cloud to help users debug data quality issues and understand data provenance for BigQuery and Cloud Storage. Use when summarizing upstream and downstream data flows, and presenting complex lineage data as an intuitive Markdown report. Don't use for generic BigQuery queries, editing lineage relationships, or downstream deprecation. Don't use for downstream blast-radius impact analysis (use datalineage-bigquery-asset-impact-analysis skill instead).

Translates Snowflake dbt SQL models to Standardized BigQuery SQL. Handles SQL compilation, Jinja macro placeholder masking, BigQuery Translation Service migration workflows, AST-based config transformations, explicit type casting, JSON extraction standardization, and deduplication. Use when migrating Snowflake dbt pipelines or models to Google Cloud BigQuery. Don't use for generic BigQuery queries or non-Snowflake SQL migrations.

It traces threat behaviors through simulated UDM events to show which existing Google SecOps rules detect them and where coverage is missing.

Provides practical guidance for preparing and managing remote Android device sessions on Google’s Developer Device Platform.

Generates code and provides documentation for the Genkit Dart SDK. Use when the user asks to build AI agents in Dart, use Genkit flows, or integrate LLMs into Dart/Flutter applications.

Develop AI-powered applications using Genkit in Go. Use when the user asks to build AI features, agents, flows, or tools in Go using Genkit, or when working with Genkit Go code involving generation, prompts, streaming, tool calling, or model providers.

Develop AI-powered applications using Genkit in Node.js/TypeScript. Use when the user asks about Genkit, AI agents, flows, or tools in JavaScript/TypeScript, or when encountering Genkit errors, validation issues, type errors, or API problems.

Develop AI-powered applications using Genkit in Python. Use when the user asks about Genkit, AI agents, flows, or tools in Python, or when encountering Genkit errors, import issues, or API problems.

It prepares Firebase CLI access and project context for app setup.

It promotes safer, more reliable gcloud operations through command-specific syntax checks, explicit project and location scoping, data reduction, and safeguards for risky actions.

It explains the control-plane API's authentication, agent configuration fields, and request-response workflow.

Explains how to build Gemini applications on Agent Platform with the Gen AI SDK, from client setup to text, multimodal, and advanced workflows.

Guides the usage of Gemini Interactions API on Gemini Enterprise Agent Platform. Use when the user wants to use the stateful, server-managed Interactions API for multi-turn conversations, background execution, streaming, structured output, and function calling on the Agent Platform.

Builds an asynchronous WebSocket client for Gemini Enterprise Live API with bidirectional streaming, ADC authentication, and session resumption.

Helps determine whether Compute Engine host maintenance caused or may cause GPU/TPU node disruptions in GKE and identify ways to protect affected workloads.

Diagnoses why GKE JobSet training workloads are restarting by correlating JobSet metrics, node-pool events, node and host health, pod scheduling status, and worker logs.

Helps interpret TPU slice conditions, identify provisioning problems, verify workload configuration, and guide safe cleanup or controller changes.

Helps evaluate GKE TPU health and performance using Cloud Monitoring metrics and PromQL.

Provides a structured diagnosis of vBAR-related TPU v6e crashes and out-of-memory failures in GKE, including possible conflicts from frequent metrics collection.

It guides teams in designing high-signal monitoring for GKE's four golden signals and cluster health while minimizing alert noise.

Guides application teams through assessing an app, containerizing it, preparing Kubernetes manifests, and deploying it to GKE.

Configures Backup for GKE to protect Kubernetes resources and persistent volume data with scheduled or manual backups and controlled restores.

Supports core Google Kubernetes Engine cluster setup and operation, including mode selection, credential retrieval, and workload deployment.

Supports running batch-processing and high-performance computing workloads on Google Kubernetes Engine (GKE).

Provides operational guidance for configuring, tuning, and troubleshooting GKE autoscaling so node capacity matches workload demand.

Guides users in choosing a GKE cluster mode and configuring production-ready settings for creation or readiness review.

Helps translate workload and cost constraints into reliable GKE ComputeClass capacity and placement policies.

It helps explain GKE billing by combining BigQuery export data, cost-allocation metadata, and live resource usage, including differences between Autopilot and Standard pricing.

Reduce GKE spending while maintaining a secure and reliable cluster posture by right-sizing workloads and choosing cost-effective capacity and commitments.

Maps a GKE version and node settings to the matching golden base image for a custom node image.

Provides GKE golden path configuration defaults, production readiness checklists, and cluster default patterns. Use when designing GKE clusters, verifying GKE production readiness, or checking configurations against GKE defaults. Don't use for setting up workload autoscaling specifically (use gke-workload-scaling instead).

Provides a workflow for preparing, deploying, and tuning AI/ML inference workloads on Google Kubernetes Engine, including model-server manifests, accelerator choices, and scaling guidance.

It turns application requirements into consistent deployment configuration that supports secure, reliable, and cost-aware operation on GKE.

Helps organize shared GKE clusters so teams and environments have appropriate access, resource, network, and cost boundaries.

Establishes a private, VPC-native networking baseline for GKE and explains how cluster addressing, DNS, egress, and network policy fit together.

Helps diagnose why GKE nodes report NotReady or Unknown by correlating node conditions and events with kubelet, runtime, and monitoring evidence, then recommends safe remediation.

Explains how to configure and assess GKE logging, metrics, Managed Prometheus, and alerting, including their operational costs.

Provides guidance for securing GKE clusters through platform-level configuration, access controls, and service integrations.

Coordinates a structured production-readiness review of GKE clusters and workloads across scalability, observability, reliability, security, backup and disaster recovery, ingress, cost, upgrades, and recommended defaults.

It supports resilient GKE operations with safeguards for cluster topology, workload scheduling, health checks, and termination.

Configures GKE edge networking, traffic routing, load balancing, and private service endpoints. Use when configuring Gateway API manifests, standard Ingress, Cloud Armor WAF security policies, Container-Native Load Balancing (NEGs), Private Service Connect (PSC), or Google-managed SSL certificates on GKE, and to troubleshoot Ingress and load-balancer 502/5xx errors, backend health-check failures, connection draining, and TLS/SSL policy enforcement. Don't use for core cluster IP planning, Dataplane V2 network policies, or node NAT egress (use gke-networking instead).

Manages GKE storage, including PVCs, PersistentVolumes, and Filestore. Use when configuring GKE storage or creating PVCs. For GCS FUSE mounts, use google-cloud-storage-fuse. For diagnosing storage failures (volume attach/mount errors, disk performance/node storage pressure, or Cloud Storage FUSE OOM), use gke-storage-troubleshooting. Don't use for database administration or replication strategies outside volume provisioning context.

It diagnoses persistent-storage failures affecting GKE workloads and prepares reviewable remediation without changing the live cluster.

Plans, executes, and validates Google Kubernetes Engine (GKE) cluster upgrades and maintenance operations for both Standard and Autopilot clusters. Produces upgrade plans, pre/post-upgrade checklists, maintenance runbooks with gcloud commands, release channel strategy, and troubleshooting guides. Handles node pool upgrade strategies (surge, blue-green), version compatibility, PDB management, and workload-specific concerns (stateful, GPU, operators). Use this skill whenever the user mentions GKE upgrades, Kubernetes version bumps, node pool maintenance, GKE patching, cluster version management, release channel selection, maintenance windows, surge upgrades, stuck upgrades, or any GKE lifecycle management task — even casual mentions like "we need to upgrade our clusters" or "plan our next GKE maintenance" or "our upgrade is stuck." Don't use for GKE cluster creation, application onboarding, general networking/routing setup, or security policy configurations (use gke-basics or relevant GKE skills instead).

Diagnoses how a GKE workload's Google Cloud identity is configured and where authentication is failing, based on available evidence.

It explains how to scale GKE workloads manually or with HPA and VPA, and how to right-size Pod resources.

Diagnoses GKE HorizontalPodAutoscaler failures and identifies root causes through read-only investigation.

It translates GKE workload-security requirements into concrete configuration guidance and clarifies where implementation depends on cluster-level capabilities.

Systematically diagnose GKE application workload failures through pod status, events, logs, and connectivity checks, then recommend GitOps-safe fixes without changing live resources.

It guides initial setup of Google's agents-cli and directs agent development on Gemini Enterprise Agent Platform to the right lifecycle workflow.

Audits Filestore instances on Google Cloud across projects for disaster recovery readiness (missing or stale backups), security access governance (overly permissive NFS export rules, 0.0.0.0/0 exposure, missing ROOT_SQUASH), and reliability compliance (Physical Zone Isolation PZI and Physical Zone Separation PZS). Use when assessing storage health posture, auditing NFS export permissions, identifying unprotected file shares, or validating zone failure domains. Don't use for Cloud Storage buckets, Persistent Disk, or NetApp Volumes.

Inspects Filestore capacity and utilization on Google Cloud, evaluates storage scaling rules, and performs capacity autoscaling (scale UP for low free space or scale DOWN for cost optimization). Use when monitoring Filestore instance headroom, resizing instance shares, configuring automated growth/shrink thresholds (custom thresholds apply globally across projects in session memory), or preventing out-of-space outages. Don't use for Cloud Storage (GCS) buckets, Persistent Disk block storage, or NetApp Volumes.

Diagnoses and resolves Filestore client mount failures on Google Cloud, permission errors (EACCES), and network timeouts (ETIMEDOUT). Use when an NFS mount hangs or fails from a Compute Engine VM, GKE pod, Cloud Run service, or Vertex AI workload, when `mount.nfs` reports "Connection timed out" or "access denied by server", when checking whether VPC ingress firewall rules or `nfsExportOptions` allow a client IP, or when a previously working Filestore share suddenly stops mounting after an administrative change. Don't use for Cloud Storage (GCS) buckets, Persistent Disk, or Cloud NetApp Volumes, and don't use for Filestore capacity scaling or backup and export-policy auditing.

Inspects, searches, and reads files and POSIX metadata on Filestore (NFS) instances on Google Cloud without local NFS client packages or root privileges. Use when browsing Filestore shares, searching files, reading remote logs, or inspecting file attributes; don't use for Cloud Storage buckets, Cloud NetApp Volumes, Persistent Disks, or modifying/deleting files.

Turns workload and traffic requirements into a recommended design for a Google Cloud global external Application Load Balancer.

Investigates Google Cloud networking issues by analyzing GCP logs, metrics, and diagnostics. Use when investigating dropped network traffic, packet drops, drop reasons, VPC Flow Logs (including Private Service Connect / PSC, serverless / App Engine Direct VPC, and cost estimation), NAT, firewall, or threat logs, querying latency and throughput metrics, or running Connectivity Tests for path diagnostics. Don't use for generic VM management or non-observability tasks.

Provides expert guidance on Identity and Access Management (IAM) and authenticating and authorizing to Google Cloud services and APIs, covering human users, service identities, Application Default Credentials (ADC), and best practices for secure access.

Establish a secure Google Cloud landing-zone foundation with baseline security controls, an organized resource hierarchy, and centralized logging and monitoring.

Helps an individual developer check Google Cloud CLI access and authentication, select a project, and confirm billing so the environment is ready for a first workload.

Queries and retrieves active security findings, external exposures, toxic combinations, vulnerabilities, threats, and sensitive data risks from Security Command Center on Google Cloud. Use when retrieving details for a security finding by its name, validating finding scope (e.g., verifying findingClass is TOXIC_COMBINATION, VULNERABILITY, EXTERNAL_EXPOSURE, or THREAT), or fetching finding details for triage. Don't use to draft remediations, apply patches, or execute configurations.

Configures Cloud Monitoring PromQL-based Service Level Objective (SLO) alerting policies on Google Cloud for resources registered in App Hub or individually specified. Generates Terraform output. Use when the user asks to configure an SLO or Service Level Objective. Don't use for standard alerting policies.

Helps design a tailored Google Cloud architecture for live, bidirectional multimodal AI workloads and develop deployment and validation guidance.

Guides end-to-end planning, design, implementation, and validation for multi-cloud open data lakehouse solutions that combine distributed data with agentic AI.

Designs a tailored multi-product agentic data science architecture on Google Cloud that incorporates opinionated best practices. Use when architecting multi-product solutions for agent-based data analytics or ML workloads. Don't use for simple queries, non-agentic pipelines, general cloud reviews, or writing agent code.

Guides a phased path from workload requirements to an approved, deployment-ready analytics solution.

Interactively discovers requirements and designs holistic, multi-product system architectures, solution blueprints, and deployment recommendations for complex workloads on Google Cloud. Use when designing end-to-end cloud solutions, selecting and integrating Google Cloud services, generating architecture diagrams, or conducting requirements discovery for new cloud workloads or migrations. Don't use for single-product tasks (use product-specific skills), initial onboarding or authentication (use google-cloud-recipe-*), Well-Architected Framework reviews or audits (use google-cloud-waf-*), or workloads covered by specialized solution skills.

It provides a structured process for turning an agent workload's requirements into a Google Cloud design, implementation plan, and validation approach.

Provides an architect-guided path for replacing an existing AI inference setup with self-hosted inference on GKE.

It guides teams through designing, deploying, and validating secure, low-latency hybrid search solutions built around AlloyDB on Google Cloud.

Provides practical guidance for securing traffic and controlling agent tool access across Google Cloud Agent Gateway paths.

Designs secure serverless applications on Google Cloud by connecting isolated compute tiers to private data services.

Helps plan a secure, low-latency conversational search solution for private enterprise content using retrieval-augmented generation.

Stores, retrieves, and manages data as objects in Cloud Storage on Google Cloud (also known colloquially as GCS) buckets. Use when you need to interact with Cloud Storage — set up a Storage MCP server (remote or local Toolbox), create or configure buckets, upload, download, stream, or transfer data, organize objects with folders, generate signed URLs, control access (IAM, ACLs, public access prevention), set storage classes (Standard, Nearline, Coldline, Archive), manage lifecycle and cost, protect data (versioning, CMEK, retention, Bucket Lock, holds, soft delete), host static websites, trigger Pub/Sub notifications, mount buckets (gcsfuse), or optimize performance. Covers gcloud storage / gsutil, JSON/XML APIs, client libraries, Terraform, and Cloud Storage MCP servers. Don't use for non-Storage MCP servers, block storage (Persistent Disk), BigQuery, or databases (Cloud SQL, Spanner, Bigtable, Firestore).

Creates Cloud Storage on Google Cloud (also known colloquially as GCS) buckets. Analyzes the workload (sensitive data, media hosting, ingestion, web hosting, archiving, backup, logging, analytics, AI/ML, or general-purpose), validates project-level security settings, and designs a secure-by-default, cost-effective configuration (location, storage class, uniform bucket-level access, public access prevention, soft delete, lifecycle) before creating it. Use whenever a user wants to create, make, set up, provision, or spin up a bucket, or needs object storage for an app, service, pipeline, or dataset — even a "simple" or "default" bucket, or when bucket creation is one step in a larger workflow. Outputs or executes the creation via gcloud, the JSON/REST API, Terraform, or SDK client libraries (C++, Java, Python, Go). Don't use for anything other than creating new buckets — for uploads, downloads, access changes, or reconfiguring existing buckets, use google-cloud-storage-basics.

Mounts Cloud Storage buckets on Google Cloud as a POSIX file system using Cloud Storage FUSE (and the gcsfuse CLI tool). Use when interacting with the gcsfuse CLI or Cloud Storage FUSE mounts: decide whether FUSE, native gs:// reads, or Filestore/Managed Lustre fits a workload, deploy tuned mounts on GKE, Compute Engine, or Cloud Run, enable and size file, stat, and list caches, tune mount flags (--implicit-dirs) or config-file settings, apply workload profiles, keep ML checkpointing safe (rename atomicity, hierarchical namespace/HNS, close-time finalization, concurrent writers), or diagnose slow training, low throughput, or bill spikes with gcsfuse metrics. Covers mount semantics, gcsfuse CLI and config files, GKE gcsfuse CSI driver (Workload Identity principal:// bindings, profile StorageClasses, sidecar sizing), and Cloud Run volume mounts. Don't use for bucket administration or data management without a mount (google-cloud-storage-basics) or fully POSIX-compliant shared file systems (Filestore, Managed Lustre; use gke-storage).

Evaluates Google Cloud workloads for cost efficiency and FinOps alignment using the Google Cloud Well-Architected Framework Cost Optimization pillar. Use when the user asks to analyze Google Cloud spend, reduce cloud bills, rightsize resources (for example, Compute, GKE, Storage, Databases), evaluate discount options (for example, CUDs, SUDs, Spot VMs), or eliminate idle capacity. Do not use for standalone product pricing lookups or non-cost architecture design.

Helps evaluate a Google Cloud workload's operational practices against the Well-Architected Framework and identify practical improvements.

Helps assess and improve Google Cloud workload performance through resource allocation, modular architecture, elasticity, and ongoing measurement.

It helps align workload reliability with user-centered service objectives, redundancy, scaling, observability, graceful degradation, and tested recovery.

Assesses a Google Cloud workload against Well-Architected security principles and identifies gaps across identity, networking, data, operations, AI, and compliance.

Helps teams reduce the environmental impact of cloud workloads by integrating sustainability into architecture and operations decisions.

Provides a consistent workflow for inspecting and managing IAM allow and deny policies on Google Cloud resources.

Safely simulates and applies Identity and Access Management (IAM) v1 (Allow) policy changes on Google Cloud. Uses the Policy Simulator to replay historical access logs against proposed policies to prevent breaking active workloads before applying the changes. Use when simulating or applying IAM v1 allow policies across Projects, Folders, or Organizations. Don't use for analyzing IAM v2 deny policies, VPC Service Controls, or performing general policy troubleshooting.

It guides the design and operation of time-limited, auditable Google Cloud role elevations through Privileged Access Manager.

Diagnoses, remediates, and manages Identity and Access Management (IAM) access issues on Google Cloud. Supports two distinct operational modes: (1) Requester Flow for developers encountering access denials (capturing error context, self-service PAM JIT activations, elevated developer self-remediation, or logging structured tickets), and (2) Resolver Flow for privileged administrators (authoritative Policy Troubleshooter analysis, deny policy exemptions, least-privilege role discovery, and PAM/IAM provisioning).

Guides authoring and validating Apache Airflow DAGs for Google Managed Service for Apache Airflow, with attention to environment constraints, version compatibility, and best practices.

Diagnoses failed Managed Airflow DAG runs and task instances by correlating task metadata, logs, DAG source, and relevant environment signals.

Helps adapt existing Managed Service for Apache Airflow DAGs to be compatible with Airflow 2.11.1 or Airflow 3.

It helps maintain a coherent, auditable incident record by managing case details, investigation notes, priority, status, and closure.

It guides the end-to-end creation, validation, testing, and approval-based deployment of YARA-L 2.0 detections, alongside coverage-gap analysis and remediation in Google SecOps.

Supports structured threat hunts in Google SecOps by testing behavioral hypotheses, checking historical telemetry for indicators, and investigating rare or anomalous activity.

Expert guidance for deep security incident and entity investigations in Google SecOps. Use when investigating cases, analyzing entities (hosts, IPs, domains, hashes, users), extracting and searching UDM events, performing asset and user timeline analysis, and detecting lateral movement across enterprise networks. Don't use for detection rule authoring or YARA-L tuning (use secops-detection-engineering), proactive hypothesis-driven hunting (use secops-hunt), initial alert triage (use secops-triage), or basic case status updates (use secops-cases).

Expert guidance for security alert triage in Google SecOps. Use when investigating and triaging security alerts, determining false positives vs. true positives, assessing entity risk, adjusting alert severity or priority, and closing or escalating alerts and cases. Don't use for deep multi-hop incident investigations across host timelines (use secops-investigate), proactive threat hunting or retroactive IoC sweeps (use secops-hunt), or authoring new detection rules (use secops-detection-engineering).

Assists in provisioning instances and databases, designing performant schemas, and querying data in Spanner. Use when designing primary keys, writing SQL queries or client library code, or diagnosing performance issues.

It organizes workload best-practice checks into a repeatable process, from choosing a scope and rules to reviewing findings for remediation.

It routes applicable requests to relevant published Google skills by consulting the catalog on demand.

Searches, retrieves, and synthesizes official Google developer documentation across Google Cloud, AI/Gemini, Android, Chrome, Web, Flutter, Go, Firebase, and other Google developer platforms. Integrates with the Developer Knowledge MCP server (search_documents, get_documents, answer_query) or the Developer Knowledge REST API fallback. Use when searching for gcloud CLI commands, API syntax, IAM permissions, official documentation, architectural comparisons, or product choice overviews. Don't use for local filesystem lookups or non-Google documentation.

It describes how to bind Google OAuth refresh tokens to a client-held P-256 key while leaving Google API calls on the standard OAuth access-token authorization path.

The gplay CLI supports Google Play Console workflows such as managing releases, app metadata, permissions, and reports.

It guides Gradle-based Android release builds, covering signing, version management, optimization, and Play Console preparation.

Set up and manage Google Play one-time products and subscriptions, including pricing, localized listings, base plans, and promotional offers.

It helps maintain Google Play listing text, localized metadata, and store images through validation, comparison, bulk sync, and targeted edits.

Converts a Fastlane Android metadata directory into gplay's file-based format, consolidating listing text in listing.json and preserving changelogs and images.

Explains how to set purchasing-power-adjusted regional prices while preserving existing Google Play product configurations.

Explains how to securely validate Google Play purchase tokens and manage the resulting product and subscription lifecycle.

Coordinates app releases, track promotions, and staged rollouts on Google Play through the gplay CLI.

Lists and downloads Google Play Console financial and app-statistics reports stored in Google Cloud Storage.

Helps retrieve, filter, inspect, and analyze Google Play reviews, with examples for replying to reviewers and monitoring feedback.

Control the staged distribution of Google Play app releases while limiting the impact of issues.

Organizes and validates existing Android store screenshots and graphics, preparing them for Google Play listing updates.

Provides a release-readiness workflow that combines local artifact and listing checks with Play Console status checks, edit validation, and release dry runs.

Manage Google Play testing-track access and release progression with the gplay CLI, using edit sessions for tester and track changes.

It manages access to Google Play Console developer accounts and individual apps, allowing permissions to be scoped at either level.

Queries Play Developer Reporting API vitals to inspect an app's stability, performance, and error data.

Helps teams turn early product launches into customer learning by finding first users, testing value quickly, and addressing the real causes of stalled adoption.

Provides practical go-to-market guidance for positioning, pricing, and selling AI products, with particular attention to enterprise trust and operational readiness.

Help leaders communicate company performance, risks, decisions, and strategy to boards and investors in a candid, decision-oriented way.

It helps teams grow developer adoption through ecosystem, community, and partner programs focused on activation, production use, and advocacy.

Provides a structured approach to enterprise account strategy, qualification, stakeholder alignment, and deal-health management.

Provides a four-phase framework for guiding enterprise customers from contract through sustained adoption and value realization.

Establish a scalable operating rhythm that keeps teams aligned and improves reporting, planning, and decision speed as a company grows.

It provides a practical framework for designing partner ecosystems that create measurable value for the company, partners, and shared customers.

It helps establish a clear, defensible market position based on current product strengths and customer resonance, then validate the message before scaling it.

Helps teams choose and build the right self-serve, sales-assisted, or sales-led growth motion by connecting acquisition, activation, conversion, and retention to measurable channel economics.

Offers decision frameworks for matching technical product pricing to customer value, cost to serve, and intended market position.

Guides production-grade Azure system design with practices for resilience, scalability, security, operations, performance, and cost.

It helps agents carry useful experience across sessions by capturing, reflecting on, persisting, and applying learnings.

Explains how applications communicate with the Copilot CLI over stdio or TCP and configure and manage SDK sessions.

Explains how to provision Microsoft Entra agent identity blueprints and OAuth2-capable agent identities through Microsoft Graph beta, including authentication and required permissions.

It evaluates existing interfaces against design-system, usability, accessibility, and visual-quality standards, or creates distinctive, production-grade frontend experiences.

Turns scattered problem details into concise, actionable GitHub issue reports.

Guides the full MCP server development lifecycle, from researching an API and choosing a framework and transport to implementing, testing, and evaluating useful tools.

It provides shared design guidance and language-specific practices for Microsoft Agent Framework development.

Checks Microsoft API and SDK usage against official documentation and working code examples.

Uses official Microsoft documentation to find or retrieve context for reliable technical explanations.

Explains how to turn text into spoken narratives with Azure OpenAI Realtime and prepare the audio for playback.

Provides a practical framework for designing, testing, and maintaining concise agent skills, including conventions for Azure SDK guidance.

Explains how Microsoft Fabric Lakehouses organize data, manage access, and support querying and performance tuning to inform solution design.

Helps developers build a code-first Power Platform app with Power Apps SDK integration and a connector example.

Reviews DAX measures for costly patterns, clarity, correctness, and maintainability, then recommends practical improvements.

Reviews a Power BI data model for architecture, performance, scalability, maintainability, data integrity, and security.

Provides a structured approach to pinpointing Power BI bottlenecks and selecting practical optimizations.

Helps shape clear, accessible Power BI reports by matching visualizations, layout, and interactions to the audience, decisions, and data.

Helps build and refine Copilot Studio-compatible MCP connectors, including JSON-RPC handling, resource-as-tool-output modeling, and OAuth security.

Helps assess and improve Power BI semantic models using modeling best practices.

Write and debug Tampermonkey userscripts - scripts that change or automate a website from inside the browser. Use when the user wants a userscript (Tampermonkey, Greasemonkey or Violentmonkey), wants JavaScript or CSS injected into a site they visit, wants page elements hidden or rearranged, wants a form auto-filled or page data scraped, needs to react to URL changes in a single-page app, needs cross-origin requests from a page script, has a userscript that does not run, or is setting one up in TypeScript. Do NOT use for Selenium, Puppeteer or Playwright automation - use a browser-automation tool; for building a browser extension (WebExtensions/Manifest V3) - write it as an extension; or for server-side scripts.

It turns code review into collaborative learning through a structured process, prioritized feedback, and a focus on actionable improvements.

Turns a proposed software change into a structured, execution-ready implementation plan with phased tasks and verifiable completion criteria.

Helps turn a project's contents into an appealing, informative overview that is easy to read.

Creates a clear, self-contained specification that defines a solution's requirements, constraints, and interfaces for generative AI use.

Turn comparisons of two project states into reusable Copilot guidance that carries observed code-evolution patterns into future changes.

Analyzes repository changes, groups related files, and records them as a Conventional Commit.

Guides incremental restructuring of existing code to improve clarity and maintainability while preserving external behavior.

It structures refactoring work into a safe, dependency-aware path from investigation through validation.

Reviews code in context and traces cross-file data flows to identify and verify security weaknesses that simple pattern matching can miss.