Skill UI

A structured workflow designed to prevent 'reinventing the wheel.' Before writing custom code, this skill guides the user through analyzing needs, conducting parallel searches across multiple channels (npm, PyPI, GitHub, MCP), evaluating candidate solutions based on maintainability and community support, and making a decision (Adopt, Extend, or Custom Build). It ensures that solutions leverage existing, proven libraries and patterns.

This skill executes the final two phases (Refinement and Completion) of the structured SPARC development methodology. It systematically elevates an implemented feature to production-grade quality by performing detailed code reviews (verifying compliance against specifications, architecture, and quality standards), maximizing test coverage (unit, integration, and edge cases), validating performance, and generating comprehensive documentation and traceability matrices. It ensures the feature is fully ready for deployment.

This comprehensive guide details the complete Test-Driven Development (TDD) workflow for Spring Boot applications. It covers best practices for writing unit tests (JUnit 5, Mockito), web layer tests (MockMvc), integration tests (SpringBootTest), and persistence tests (DataJpaTest). It also instructs how to use Testcontainers for realistic database simulations and achieve high code coverage with JaCoCo, ensuring robust and maintainable codebases.

A comprehensive CI/CD quality gate checklist for Spring Boot projects. It guides developers through mandatory steps including building, static analysis (SpotBugs, PMD), running unit/integration tests, measuring code coverage, performing security scans (OWASP), and reviewing diffs before merging or deploying.

This comprehensive guide demonstrates how to achieve highly testable Swift code using protocol-based dependency injection. By abstracting external concerns—such as file systems, networking, and external APIs—into small, focused protocols, developers can write deterministic unit tests that mock side effects and error paths, ensuring robust architecture across different environments (App, Test, Preview).

This skill automates the Test-Driven Development (TDD) repair loop. Given a failing unit test, it spawns a bounded, headless LLM agent to automatically modify the source code until the test passes. It closes the development loop by treating the test's pass/fail status as the definitive fitness function, ideal for CI failure triage and local TDD workflows.

This workflow guides developers through Test-Driven Development (TDD) principles. It mandates writing tests (unit, integration, E2E) before writing implementation code, ensuring minimum 80% test coverage. The structured process (Red -> Green -> Refactor) guarantees robust code quality, effective bug fixing, and safe feature addition, while integrating Git checkpoint commits for full traceability.

This skill automatically detects missing test coverage within a codebase and generates actionable, detailed test suggestions. It is essential for developers who need to identify untested code areas, assess coverage gaps after implementing new features, or proactively determine what unit tests should be written next to improve overall code quality and robustness.

This skill clusters a collection of vectors (embeddings, e.g., code snippets) within a designated namespace using graph community detection algorithms (Spectral/Louvain). It is essential for discovering underlying themes, identifying natural groupings, and analyzing the relationships within large, unstructured vector datasets. Use it when you need to organize embeddings based on semantic relatedness rather than simple keyword matching.

This tool provides access to a community gallery for WebAssembly (WASM) agents. Users can browse available agents, search for specific functionality, install pre-built agents, publish their own creations, or export agents for sharing. It streamlines the entire lifecycle of WASM agent development and deployment.

This tool performs a comprehensive audit of the project's stored auto-memory. It analyzes learned knowledge to identify actionable patterns for promotion to core rules, flag stale or outdated entries, and suggest opportunities for consolidating redundant knowledge. Use it after major development phases or when the memory knowledge base becomes crowded to maintain system knowledge quality.