Skill UI

Guides on structuring NUnit test projects, naming fixtures, arranging tests, and applying standard plus data-driven attributes along with assertions and mocking tactics to keep suites clear, independent, and repeatable.

This guide provides a comprehensive setup for local development workflows for Figma plugins and external REST API integrations. It enables developers to build, test, and iterate rapidly using hot reloading, mocked API fixtures, and structured project templates. Essential for creating design-to-code pipelines and advanced Figma tooling.

This comprehensive guide establishes a structured local development environment for integrating with the Navan API. Since Navan does not provide a sandbox, this workflow is crucial for minimizing calls to the production API. It implements token caching to persist access tokens, detailed request logging for debugging, and mock fixtures to allow for reliable, safe offline testing during the development cycle.

This skill establishes a local development loop for OneNote integrations. It uses Mock Service Workers (MSW) to intercept calls to the Microsoft Graph API, providing realistic, fixture-based responses (e.g., Notebooks, Sections, Pages). This allows developers to rapidly build and test OneNote features without needing live Azure credentials or worrying about rate limit restrictions during development cycles.

This guide provides a comprehensive setup for Continuous Integration (CI) and Continuous Deployment (CD) for SerpApi integrations. It outlines using fixture-based unit tests via GitHub Actions for Pull Requests (preventing API credit consumption) and controlled live integration tests on the main branch. This ensures robust and reliable search result parsing validation.

This utility provides a robust local development loop for integrating search APIs (like SerpApi). By caching real search responses into fixtures, developers can test search integrations, write unit tests, and develop features offline without incurring continuous API costs. It includes detailed instructions and code examples for Python and Node.js, ensuring cost-effective and reproducible testing.

This minimal example demonstrates the structure of an MDA source file, including advanced frontmatter fields (metadata) and how to properly implement relationship-graph footnotes. It serves as a crucial reference fixture for users learning the MDA source format.

This fixture is designed to verify basic compiler conformance and confirm target projection accuracy. It serves as a foundational testing tool in the compilation pipeline, ensuring that the compiler adheres to specified standards and correctly targets the intended platform architecture. Use it for early-stage validation of compiler output and system compatibility.

This tool provides a read-only view over per-turn decision logs, aggregating data on skill co-occurrence patterns, meta-skill usage statistics, and router fixtures. It returns a structured JSON summary, making it ideal for analyzing historical skill usage, optimizing workflows, and feeding insights into downstream LLM models.

An internal, non-user-invocable tool designed to validate candidate meta-skills. It runs critical G3 (positive) and G4 (negative) smoke tests by simulating meta-resolution using LLM-generated fixtures. This ensures the structural integrity and robustness of the skill in a cross-vendor environment.

This skill generates comprehensive, production-grade unit and integration tests using the Python pytest framework. It covers advanced patterns such as fixtures (with scope and teardown), parametrization, custom markers, mocking external dependencies, and best practices for writing robust and maintainable test suites. Use this when implementing detailed test coverage for Python code.

This guide outlines a comprehensive, agent-focused testing workflow for modern C++ (C++17/20) using GoogleTest and CMake/CTest. It teaches key concepts like the TDD cycle (Red-Green-Refactor), utilizing mocking (gmock) and fixtures for isolation, setting up robust CI/CD integration, and debugging complex issues using sanitizers (ASAN, TSAN) and coverage analysis. Use this when writing, updating, or ensuring the functional robustness of C++ codebases.