Skill UI

This comprehensive catalog provides essential abstractions for securing web APIs. It covers the entire lifecycle of authentication, including handling roles, users, and teams. Features include robust mechanisms for managing API keys (before/after events) and dedicated use cases for user and role creation/deletion, ensuring highly scalable and secure backend development.

This API provides core abstractions for managing system initialization and lifecycle events. It includes `InstallSystemUseCase` for running system-wide setup logic, and `SystemInstalledEventHandler` for implementing hooks that execute immediately after the system is successfully installed. It is essential for developing robust, modular, and reliable large-scale applications requiring structured bootstrapping.

This module provides core abstractions for handling long-running, asynchronous background tasks within an API context. It introduces `TaskDefinition` to define the complete lifecycle and hooks for a background task, and `TaskService` to programmatically trigger and manage these operations. It is essential for backend development requiring robust, non-instantaneous processing.

A comprehensive API catalog for managing the entire tenant lifecycle in multi-tenant applications. It provides structured abstractions, including Use Cases, Repositories, and various Event Handlers (before/after hooks), facilitating the creation of robust, scalable, and loosely coupled multi-tenant backend systems.

This module provides comprehensive API abstractions and use cases for managing multi-tenant systems. It covers the entire tenant lifecycle, including creation, installation, enabling, disabling, retrieval by ID, and model extension. Developers can use these structured patterns to ensure robust, scalable, and maintainable multi-tenancy implementation within their services.

This catalog provides comprehensive infrastructure abstractions and hooks for the Webiny ecosystem. It includes standardized lifecycle hooks (Before/After Build/Deploy/Watch) and specialized services (Logger, UI, AWS interactions) for various modules (Admin, API, Core). Use these standardized interfaces to seamlessly integrate custom logic into your build and deployment pipelines, ensuring modularity and consistency.

XcodeBuildMCP is a unified skill set designed to streamline the entire mobile and desktop development lifecycle. It replaces raw command-line tools like xcodebuild, xcrun, and simctl, providing structured workflows for iOS, macOS, watchOS, tvOS, and visionOS. Capabilities include project discovery, managing simulator and physical device workflows, advanced UI automation (gestures, view inspection), robust logging, and deep debugging using LLDB. It simplifies complex build, test, and run operations across multiple platforms.

The official skill for the XcodeBuildMCP CLI, providing a unified interface for complex Apple development tasks. It streamlines build, test, run, debug, and UI automation across iOS, macOS, watchOS, tvOS, and visionOS. Use this tool to simplify multi-stage workflows and manage project lifecycles without relying on raw, complex xcodebuild commands.

This comprehensive guide serves as a decision flowchart for developers using Claude Code. It details when to use specific slash commands (/plan, /compact, /loop), select specialized agents (planner, code-reviewer, build-error-resolver), or invoke workflow skills (e2e-testing, tdd-workflow). It helps users select the optimal tool combination for complex tasks across the entire software development lifecycle, including feature planning, bug fixing, testing, and architectural design.

This skill guides users through building comprehensive Smart City and IoT solutions on the Azure platform. It covers the entire solution lifecycle, from initial high-level requirements and defining city domains (e.g., traffic, energy) to designing robust, scalable architectures. Outputs include detailed reference architectures, security checklists, cost strategies, and phased implementation roadmaps for enterprise deployment.

A robust application framework for Go, built on the uber-go/dig container. It provides advanced features essential for long-running services, including structured dependency injection, explicit lifecycle hooks (OnStart/OnStop), modular composition, and signal-aware graceful shutdown handling. Ideal for building robust daemons, HTTP servers, and background workers.

This skill guides the development of robust, Unix-like Command Line Interfaces (CLIs) in Go using the industry-standard `cobra` library. It covers the entire lifecycle of a CLI application, including command tree setup, managing persistent vs. local flags, advanced positional argument validation, and utilizing the full execution hook chain (RunE). Ideal for engineers adopting or maintaining sophisticated Go CLI projects.