Skill UI

A comprehensive guide for building or reviewing SwiftUI User Interfaces that utilize the modern Liquid Glass aesthetic. This skill focuses on correctly implementing native Apple APIs (like `glassEffect` and `GlassEffectContainer`) while ensuring proper fallback mechanisms, modifier ordering, and performance for iOS 26+ devices. Ideal for adopting cutting-edge iOS design patterns.

Design scalable and cost-effective Azure architectures using Bicep infrastructure-as-code templates. The tool helps gather requirements, recommend patterns, generate IaC templates, optimize costs, and configure CI/CD pipelines for services like AKS, App Service, and Cosmos DB.

This comprehensive workflow guides the design, optimization, and deployment of scalable, cost-effective Google Cloud Platform (GCP) architectures for both startups and large enterprises. It covers the full lifecycle, from gathering detailed requirements (compliance, SLA) and recommending optimal patterns (Serverless, GKE, Data Pipelines) to estimating costs, generating Infrastructure as Code (IaC) using Terraform, setting up CI/CD pipelines, and completing a thorough security review.

This guide provides comprehensive patterns for designing and implementing secure multi-tenant SaaS applications using shared databases. It covers critical techniques like Row-Level Security (RLS) in PostgreSQL, implementing tenant-aware middleware in TypeScript (Express/Fastify), and enforcing data scoping at the ORM level (Prisma/Drizzle). Learn how to prevent data leakage and manage tenant isolation across shared schemas.

This guide outlines the architecture and implementation steps for building a robust, production-ready design system. It covers core elements like design tokens, reusable components, and layout patterns. Ideal for teams needing to maintain design consistency, ensure accessibility, and synchronize design (Figma) with implementation (Storybook).

Gradio is a powerful Python library designed for creating interactive web user interfaces and showcasing machine learning demos quickly. This skill covers core patterns like Interface, Blocks, and ChatInterface, allowing users to build complex applications, components, and event-driven chatbots with minimal effort. Ideal for rapid prototyping and deep learning model visualization.

This comprehensive guide covers idiomatic C# and modern .NET best practices for building robust, high-performance, and maintainable applications. Topics include immutability, dependency injection, explicit coding, proper async/await usage, the Options pattern, and the Result pattern. Essential reading for developers designing services with ASP.NET Core.

This resource is designed to document and guide the implementation of various architectural patterns and best practices when developing backend applications using the NestJS framework. It helps developers structure their code for maximum scalability and maintainability.

A comprehensive collection of agent skills for rigorously auditing digital interfaces and user flows. It evaluates designs against 168 research-backed UX/UI principles, detects common design antipatterns, and provides specialized review for AI-powered interfaces, ensuring adherence to modern best practices.

This guide outlines how to build new API connectors or providers that strictly adhere to the existing integration architecture and patterns of a target repository. It is designed for adding integrations while maintaining architectural consistency (e.g., layout, configuration schema, authentication model, and testing style), preventing the creation of novel, unsupported patterns.

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.

This skill provides comprehensive guidance on idiomatic Go patterns for building production-ready, robust applications. It covers best practices like functional options, proper constructor design, resource management (timeouts, graceful shutdown), error handling, concurrency patterns, and architectural styles (DDD, Hexagonal). Use it when structuring complex Go APIs, defining service boundaries, or auditing existing code for common anti-patterns and performance pitfalls.