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.

Guides designing robust microservices with service boundaries, event-driven communication, saga orchestration, API gateways, health checks, and anti-pattern awareness for resilient distributed systems.

This skill implements a sophisticated, config-driven rules engine for OpenRouter API calls. It dynamically determines the optimal large language model (LLM) by evaluating a comprehensive context, including user subscription tier, remaining cost budget, specific task type (code, chat), required tools, and latency requirements. This is essential for building production-grade, cost-aware, and robust LLM orchestration systems.

This guide demonstrates how to implement clean and robust asynchronous pipelines in TypeScript using `TaskEither` from `fp-ts`. It solves the common problem of deeply nested, unmanageable `try/catch` blocks, allowing developers to compose sequential API calls and operations while correctly handling success and failure paths in a functional, immutable manner. Ideal for complex data fetching and workflow orchestration.

Guides developers to wrap Feishu API calls into reusable lark-cli skills, covering API research, command templates, and best practices for authentication, permissions, and orchestration.

A robust, production-ready architecture pattern for integrating with multiple Adobe APIs, including Firefly Services, PDF Services, and I/O Events. This pattern enforces a layered structure (API -> Service -> Client -> Infrastructure), ensuring clean separation of concerns, centralized authentication, robust error handling boundaries, and scalable workflow orchestration for enterprise applications.

A comprehensive guide to setting up a robust local development loop for Hex API orchestration. This includes defining the project structure, creating a typed API client using TypeScript, and implementing mocked unit tests (e.g., using vitest) to ensure fast iteration and reliable testing of data pipelines and external service interactions.

This guide provides production-ready patterns for integrating with the Hex platform API using TypeScript and Python. It covers essential best practices like robust retry logic, typed client usage, pipeline orchestration, and Airflow integration, helping developers establish standardized, reliable coding standards for complex Hex workflows.

This comprehensive guide provides a production-grade reference architecture for building robust Text-to-Speech (TTS) and voice applications using the ElevenLabs API. It covers detailed project structure, service layer design (including TTS orchestration, voice management, and caching), configuration handling, and best practices for streaming and multi-model orchestration, ensuring scalability and reliability in a commercial SaaS environment.

A comprehensive TypeScript SDK providing production-ready patterns for interacting with the Fly.io Machines REST API. It includes a typed client for managing the entire machine lifecycle—creation, state polling, and deletion—across multiple global regions. Features like robust error handling, rate-limit retries, and deployment builders ensure reliable multi-region orchestration for edge computing applications.

This guide details the recommended reference architecture and project structure for integrating with the Hex platform. It covers best practices for designing robust data pipelines, including components like orchestration layers (Airflow, Dagster), API clients, and standardized project layouts. Use this when starting new Hex integrations or reviewing complex data workflows.

This skill provides a comprehensive, production-grade reference architecture for building robust Notion integrations. It defines a multi-layered structure, including client singletons, repository patterns, service orchestration, and caching mechanisms. It is essential for migrating ad-hoc API calls to scalable, event-driven, and highly reliable enterprise applications that incorporate rate limiting, sophisticated error handling, and comprehensive testing strategies.