Skill UI

This comprehensive workflow guides the entire lifecycle of building a complex full-stack feature, from initial architectural design to final integration testing. It enforces an API-first approach, ensuring that the database schema, backend services, and frontend components are developed cohesively, promoting scalability, testability, and adherence to modern industry best practices.

This library provides comprehensive patterns for building robust Clinical Decision Support Systems (CDSS) integrated into Electronic Medical Records (EMR). It ensures patient safety by implementing critical checks such as drug interaction screening, weight/age/renal-adjusted dose validation, and standardized clinical scoring (e.g., NEWS2). The engine uses pure functions, guaranteeing high testability and reliability for critical medical insights.

This guide details the Hexagonal Architecture (Ports and Adapters) pattern, a robust method for decoupling core business logic from external infrastructure concerns. It teaches how to structure applications to make the domain model independent of databases, UI frameworks, or message queues. Implementing this pattern drastically improves testability, maintainability, and the ability to swap out external services without rewriting business rules.

Guides structuring Flutter applications using layered architecture, MVVM, repositories, and dependency injection for maintainability and testability. Use when scaffolding a project, refactoring into layers, creating view models/repositories, wiring dependency injection, or implementing unidirectional data flow.

Provides a comprehensive guide to Dependency Injection (DI) in Go. It covers the principles of loose coupling, testability, and separation of concerns, contrasting manual constructor injection with popular DI libraries (Wire, Dig, FX). Ideal for designing service architectures, refactoring coupled code, or understanding the principles of Inversion of Control in Go applications.

A comprehensive code review tool designed for C#/.NET projects. It evaluates the implementation of key design patterns (Command, Factory, Repository) and adherence to SOLID principles. The review covers architecture, best practices (async/await, logging), security, testability, and clean code principles, providing actionable recommendations for improvement.

Shows how to apply the Extract Method refactoring in Java to improve readability, modularity, and testability by isolating reusable behaviors from complex methods while preserving the original functionality.

This skill analyzes an existing codebase using domain context and architectural decisions to identify architectural friction and "deepening opportunities." It proposes refactored improvements to increase module depth, enhancing testability, improving maintainer locality, and making the codebase more navigable for AI tools. It focuses on transforming shallow modules into robust, deeply leveraged components.

This skill guides users through setting up a robust, local development loop for Notion integrations. It covers creating dedicated development tokens, structuring the project for testability, implementing mocked SDK unit tests, and handling API rate limits with exponential backoff retries. This ensures rapid, reliable iteration and testing without compromising production data safety.

This skill generates detailed implementation plans for multi-step tasks based on specifications before coding begins. It defines file structures, task granularity, and step-by-step instructions (TDD approach) to ensure clarity and testability. It includes self-check mechanisms and execution handoff options for AI agents or developers.

Mason is the dedicated builder agent responsible for writing clean, functional, and production-ready code. He strictly adheres to architectural blueprints and defined checklists, ensuring every feature is implemented with high code quality standards, including comprehensive error handling, security best practices, and testability. Ideal for the core development phase of complex projects.

A comprehensive guide and shared vocabulary for designing and structuring complex software modules. Use this when you need to refine an existing module's interface, identify opportunities for deepening its capabilities, determine optimal internal seams, or improve code testability and AI-navigability. It establishes clear principles for Module, Interface, Depth, and Seam.