Skill UI

A comprehensive guide covering best practices for unit and integration testing, including Test-Driven Development (TDD) and Behavior-Driven Development (BDD). This guide details factory functions for creating reusable mock data and props, advanced mocking strategies for modules and hooks, and custom rendering utilities, ensuring tests are maintainable and reliable in React/TypeScript environments.

This skill generates code to create complex, interactive 3D scenes and visualizations on the web using the Three.js library and WebGL. It covers the entire development lifecycle, including setting up the core components (Scene, Camera, Renderer), defining geometry, applying materials, adding lighting, and implementing animation loops. Ideal for web developers needing to display product mockups, scientific data visualizations, or immersive user experiences.

Automates creation of unittest-based test suites by guiding developers through industry best practices for unit and integration testing, mocking, and framework setup while validating outputs against common standards.

This guide establishes a fast, reproducible local development workflow for GPU workloads using Vast.ai. It covers key practices such as testing Docker images locally (in CPU mode), mocking external APIs like Vast.ai, and implementing robust unit and integration tests. This is essential for minimizing cloud GPU costs and accelerating the iteration cycle for complex AI/ML projects.

This skill automates the creation of comprehensive test suites for any codebase. Utilizing advanced AI capabilities, it analyzes function signatures, automatically identifies potential edge cases, generates meaningful assertions, and produces necessary mock data and fixture files. It is essential for developers needing robust unit tests, increasing code coverage, and adopting Test-Driven Development (TDD) workflows across various frameworks like Jest or pytest.

Generates high-fidelity mobile and web UI/UX mockups with atomic design principles, responsive layouts, and accessible design tokens via muapi.ai for product requirements that need professional wireframes or design systems.

Offers testing guidance covering TDD workflows, unit/integration/E2E organization, framework support, mocking strategy, and coverage to help teams deliver reliable, well-structured test suites.

An adaptive and persistent coaching system designed for the entire job search lifecycle. It covers critical stages including Job Description (JD) decoding, resume optimization, mock interviews (behavioral, technical, case), transcript analysis, storybank building, and comprehensive salary negotiation support. The system tracks your progress and provides tailored coaching plans across 23 commands.

A comprehensive guide to writing reliable and maintainable tests for Kotlin projects. This skill covers modern testing patterns using Kotest for various spec styles (FunSpec, BehaviorSpec), MockK for dependency mocking, and enforces TDD principles (RED/GREEN/REFACTOR). Learn how to implement unit tests, property-based testing, and ensure high code coverage with Kover.

This guide provides a comprehensive workflow for Test-Driven Development (TDD) within Laravel applications. It covers best practices for writing unit, feature, and integration tests using modern tools like Pest and PHPUnit. Learn how to manage database states, mock external services, and achieve high code coverage efficiently.

This guide provides comprehensive testing patterns for C# and .NET applications. It covers best practices using xUnit, FluentAssertions, and advanced techniques like mocking (NSubstitute/Moq), parameterized testing, and full integration testing using Testcontainers and WebApplicationFactory. Ideal for improving test quality, coverage, and developing robust, maintainable codebases.

Provides a comprehensive guide to the `stretchr/testify` library for Go testing. It covers essential features like readable assertions (assert/require), mocking dependencies, setting up test suites, and advanced patterns (e.g., JSONEq, Eventually). Use this when writing robust unit tests, ensuring failures are self-explanatory, and managing complex test lifecycles in Go projects.