Skill UI

This tool automates the entire process of creating a complete, production-ready application structure solely from an OpenAPI (Swagger) specification. It analyzes the spec to design the application architecture, generating all necessary layers including controllers, service logic, data models (DTOs), and repositories, adhering to best practices, framework conventions, and separation of concerns. The output includes unit tests, configuration files, and setup instructions, providing a robust, ready-to-use codebase.

A powerful tool that converts complex Unified Modeling Language (UML) diagrams—such as Sequence, Class, Activity, and State diagrams—into plain text ASCII art. This is crucial for documentation in environments that do not support image embedding, such as terminal sessions, README files, or Git commit messages. Supports both standard ASCII and enhanced Unicode ASCII formats for better visual fidelity.

This skill demonstrates how to use Playwright MCP to programmatically automate the process of inputting data into a web form. It covers various input types, including text fields, date selection, time setting, and file uploads. The process simulates realistic user interaction for data entry or form submission testing, emphasizing the ability to fill data without final submission for review purposes.

This tool automates the creation of robust Playwright end-to-end tests. Given a detailed user scenario, it executes a multi-step process using the Playwright MCP, generating high-quality, executable Playwright TypeScript code. It saves the test file and automatically runs and iterates the test until it passes, ensuring comprehensive functional coverage and reliable validation.

An advanced, AI-powered agent designed to generate comprehensive and workable unit tests for virtually any programming language (e.g., Python, C#, Java, Go, TypeScript). It operates via a sophisticated multi-agent pipeline (Research → Plan → Implement → Build → Test → Fix → Lint). This ensures generated tests are not only written following project conventions but also compile, pass all tests, and effectively improve code coverage.

A comprehensive guide to creating production-grade Product Requirements Documents (PRDs). This skill helps bridge the gap between vague business concepts and concrete technical specifications for modern software systems and AI features. It enforces a structured workflow, ensuring all necessary components—from user stories and success KPIs to technical architecture and risk analysis—are defined.

This guide provides comprehensive patterns for migrating Enzyme unit tests to React Testing Library (RTL), especially when upgrading to React 18. It emphasizes the crucial philosophical shift from testing internal implementation details (like state or props) to asserting visible user behavior. Learn best practices for rewriting shallow/mount/simulate calls into modern, accessible, and resilient RTL queries, ensuring your tests reflect how a user genuinely interacts with the component.

This guide implements the Red-Green-Refactor cycle, the core methodology of Test-Driven Development (TDD). It teaches developers to first write a failing test (RED), then implement the minimum required code to make the test pass (GREEN), and finally improve the structure and clarity of the code without changing its behavior (REFACTOR). Use this guide when mastering TDD, ensuring robust unit test coverage, or following best practices for writing resilient software.

A comprehensive guide and checklist for identifying potential risks when migrating database applications from Oracle to PostgreSQL. It systematically cross-references code and migration artifacts against known behavioral differences, covering issues such as empty string handling, refcursors, type coercion, sorting logic, and timestamp semantics. Use this tool during the planning phase to proactively mitigate risks, or during validation to ensure comprehensive integration test coverage for the new PostgreSQL environment.

This tool generates a complete, production-ready project scaffold for a Model Context Protocol (MCP) server written in Ruby. It includes the necessary file structure, gem dependencies, Rake tasks, and boilerplate code for defining tools, prompts, and resources, accelerating backend development for AI applications.

This tool scaffolds a complete, production-ready Model Context Protocol (MCP) server project written in Rust. It utilizes the official `rmcp` SDK to ensure full compatibility. The generated structure includes modules for handling logic, defining tools, managing prompts, and providing resources. Users can configure different transports (stdio, SSE, HTTP) and immediately run the server for integration testing or production use.

This comprehensive guide outlines essential best practices and structural checks for developing robust Salesforce Apex code. It covers critical areas such as preventing governor limit exceptions (e.g., bulk safety), enforcing security (CRUD/FLS), preventing SOQL injection, adhering to sharing models, and implementing modern Apex idioms. It also mandates rigorous testing strategies (Positive, Negative, Bulk) and proper trigger architecture.