Skill UI

A comprehensive guide and implementation using TypeScript to establish production-grade observability for Linear API integrations. This includes defining Prometheus metrics (tracking latency, error rates, rate limits, and webhooks), implementing structured logging (using pino), and setting up robust health check endpoints. It ensures full visibility into API performance and system health, critical for mission-critical SaaS applications.

A comprehensive guide to optimizing interactions with the Linear API. Learn advanced techniques to improve application performance by eliminating N+1 queries, implementing robust caching strategies for static data (e.g., teams, states), managing cache invalidation via webhooks, and efficiently batching multiple mutations into single GraphQL requests. Essential for building scalable, low-latency SaaS applications.

This guide provides advanced techniques for managing API rate limits (429 errors) and complexity budgets when interacting with the Linear API. It covers reading rate limit headers, implementing exponential backoff with jitter for robust retries, controlling request bursts via token buckets, and optimizing GraphQL queries to minimize complexity scores. Use this when developing reliable integrations that must adhere to strict API quotas.

This guide provides production-grade architectural patterns for integrating with the Linear API. It helps developers choose the optimal strategy—be it Simple SDK calls, Service-Oriented Gateways with caching, or Event-Driven Webhooks—based on system complexity, scale, and real-time requirements. Includes patterns like CQRS and rate limiting best practices.

A comprehensive guide covering advanced patterns for the Linear SDK using TypeScript/JavaScript. Learn how to implement efficient cursor-based pagination, avoid N+1 query problems by batch-loading relations, perform complex filtering, and handle API calls with type-safe error management when integrating with the Linear GraphQL API.

This guide details secure methods for connecting external applications to the Linear API. It covers essential security practices, including secure storage of API keys using environment variables, implementing OAuth 2.0 with PKCE for robust authentication, managing token refresh cycles, and verifying webhook signatures using HMAC-SHA256. Essential for building production-grade, secure integrations.

This comprehensive guide outlines a multi-step process for safely upgrading the Linear SDK across major versions. It details how to check for breaking changes (like renamed fields or changed return types), implement compatibility layers using patterns like the Bridge pattern in TypeScript, run thorough unit and integration tests, and establish a robust deployment and rollback plan, ensuring zero downtime migration.

A comprehensive framework for setting up and processing Linear webhooks. This skill demonstrates best practices for real-time event handling, including mandatory HMAC signature verification, replay attack prevention, and robust event routing for various data types (Issues, Comments, Projects). Ideal for building reliable, real-time integrations between Linear and external systems.

Guide to automating Linkhut operations through Composio’s toolkit via Rube MCP, covering discovery of current tool schemas, connection validation, multi-tool execution patterns, memory/session handling, and pagination-aware workflows.

Automate Linkup operations through Composio's Linkup toolkit by orchestrating Rube MCP calls (search tools, manage connections, execute multi-tool workflows) while strictly following schema discovery, connection validation, memory handling, and pagination guidance.

Automated Linux Commands Guide skill offers step-by-step help with foundational DevOps tasks such as version control, containerization, CI/CD, and infrastructure routines whenever you mention linux commands guide.

A comprehensive guide for authorized security assessments, detailing systematic methods to escalate user privileges from low-level access to root control on Linux systems. Techniques covered include comprehensive system enumeration, exploiting kernel vulnerabilities (e.g., dirty pipe), abusing misconfigured sudo permissions (using gtfobins), and exploiting vulnerable SUID binaries.