microsoft/FluidFramework

Guides developers through the API change review process, including release tag assignment, API Council review, breaking change classification, and deprecation. Triggered by CI readiness checks when API report diffs are detected.

Refines rough ideas into fully-formed designs through structured Socratic questioning, alternative exploration, and incremental validation. Use before writing any code or implementation plans.

Guides the implementation of user interfaces with design variation exploration, frontend setup, iterative feedback, and proper integration into the application.

Runs formatting, policy, and syncpack checks on changed packages before pushing, catching common CI failures like stale API reports and missing changesets. Useful for pre-push validation in large TypeScript monorepos.

Comparison Base resolves the correct merge-base for a review branch against its target branch. Use it to identify the commit and remote needed for PR comparisons and change analysis.

Guides through the process of creating custom skills for agent profiles, covering requirements gathering, directory structure, writing SKILL.md, and bundling scripts. Use when building reusable, persistent agent instructions.

Guides debugging by creating external test scripts that replicate bugs, adding logs, and iterating until the issue is resolved. Suitable for isolating elusive bugs without internal mocking.

Automates the workflow for finalizing a development branch: runs tests, formatting, linting, type checking, creates a PR, and ensures CI passes. Ideal for developers ready to submit their feature implementation for review.

Provides a comprehensive reference for investigating Fluid Framework telemetry using Kusto queries, including error analysis, session lookups, deployment monitoring, and performance metrics. Use when querying Office_Fluid_FluidRuntime_* tables or investigating Fluid-related incidents.

Automates composing and creating pull requests in the Fluid Framework repository with project-specific title and body conventions. It guides the user through approval before pushing and opening the PR on GitHub.

Guides composing PR titles and descriptions for the Fluid Framework repo, including two acceptable title styles and a body template with required sections.

Automates Fluid Framework client releases — minor and patch releases, version bumps, changelogs, release notes, and type test updates. Detects release state from schedule and repo, and executes the appropriate phase, with fallback to GitHub issues on failure.

Splits large tasks into smaller chunks managed by subagents to prevent context window overflow. Use when long-running tasks cause context issues, ensuring coherent final output through iterative testing.

Defines a structured workflow for AI coding agents: checks for protected branches, sets operating modes (full-send or copilot), enforces research, planning, TDD, documentation, and strict coding guidelines.

Generates a consolidated shift status dashboard by querying incident management, CI/CD pipelines, error logs, and team communications in parallel. Use for quick operational overviews of OCE status, including incidents, build health, and error rates.

Pipeline Test Triage analyzes Azure DevOps test failures for Fluid Framework pipeline runs. Use it to summarize failing tests, compare runs, separate flaky issues from real bugs, and identify when a bug should be filed.

Policy Check runs pnpm policy-check from the repo root to validate package compliance. Use it for a specific package with --path, or run the repository-wide check when changes may affect other packages.

Provides a structured approach to code review feedback: fetch comments, clarify requirements, implement one change at a time, run tests, and push. Emphasizes verification and quality over performative agreement.

Review checks a branch or diff for correctness, API compatibility, architecture, tests, performance, and security. Use it when you need a concise code review with optional deeper analysis.

Review PR Locally checks out an Azure DevOps or GitHub pull request into an isolated git worktree so a human can inspect it in their editor. It also posts only the review comments the human explicitly requests, using ADO tools or the gh CLI.

Use when errors occur deep in execution and you need to trace back to find the original trigger - systematically traces bugs backward through call stack, adding instrumentation when needed, to identify source of invalid data or incorrect behavior

Captures screen context using platform-specific CLI tools and loads images for visual analysis. Use when asked to take a screenshot or analyze UI issues.

A systematic four-phase debugging framework (root cause investigation, pattern analysis, hypothesis testing, and implementation) for when you encounter any bug, test failure, or unexpected behavior, ensuring you understand the issue before attempting fixes.

Follow a disciplined test-driven development cycle: write a failing test first, implement minimal code to pass, then refactor. Use for any feature or bugfix to ensure tests genuinely verify behavior.

Prevents testing mock behavior, production pollution with test-only methods, and mocking without understanding dependencies. Use when writing or changing tests, adding mocks, or tempted to add test-only methods to production code.

Trigger Pipelines For Copilot PR posts two /azp run comments on a specified PR in microsoft/FluidFramework. Use it when a Copilot-created pull request needs Azure DevOps pipelines started.

After code changes, use this skill to update Noridocs—documentation files describing folder architecture and implementation—via an automated subagent.

Create isolated git worktrees for parallel development with automatic project setup and testing. Use when you need separate workspaces without cloning the repo again.

Provides instructions for effectively using skills in Claude Code, including how to read, announce, and apply skill workflows. Use this meta-skill before any conversation to ensure proper skill usage.

Guides through installing Playwright, writing scripts to interact with a live webapp, and iteratively debugging with logs and screenshots. Use for building features or fixing bugs in any webapp frontend.

Creates comprehensive implementation plans with exact file paths, complete code examples, and verification steps for engineers with no codebase context. Use when design is complete to produce bite-sized, actionable tasks.