Skill UI

A comprehensive guide and implementation pattern for managing rate limits, throttling, and ensuring idempotency when interacting with the Databricks API. This skill demonstrates techniques like exponential backoff with jitter, token-bucket rate limiting, and using idempotency tokens to make bulk and concurrent API calls reliable and efficient, minimizing HTTP 429 errors.

A comprehensive guide to production-ready patterns for the Databricks Python SDK. This skill covers essential best practices including singleton client initialization, structured error handling with typed exceptions, context-managed cluster lifecycle control (ensuring cleanup), and implementing type-safe job definitions. It is essential for building robust, maintainable, and idiomatic integrations with the Databricks platform.

This skill provides a comprehensive guide to configuring event-driven workflows and robust notification systems for Databricks jobs. It covers setting up various notification destinations (Slack, Teams, Email, PagerDuty) and triggering alerts based on job lifecycle events (success, failure, start). Furthermore, it demonstrates advanced monitoring using system audit tables and creating automated SQL alerts for critical data pipeline monitoring.

This skill guides the definition of relationships and integration contracts between distinct bounded contexts within a complex system using Domain-Driven Design (DDD) patterns. It is crucial for preventing domain leakage, planning anti-corruption layers (ACLs), and clarifying ownership boundaries when multiple services interact, ensuring a robust and scalable system architecture.

This skill guides the architectural definition of complex business domains using Domain-Driven Design (DDD). It helps in defining core subdomains, separating services by bounded contexts, and establishing a unified ubiquitous language. It is essential for decomposing monoliths, structuring microservices, and aligning team ownership with clear domain boundaries.

This skill guides the application of Domain-Driven Design (DDD) tactical patterns, including defining aggregates, modeling value objects, managing repositories, and utilizing domain events. It helps developers translate complex domain rules into clean, robust, and behavior-rich code structures, ensuring invariants are explicitly enforced.

This specialized skill acts as an expert debugger, designed for deep root cause analysis of software errors, test failures, and unexpected behavior. It guides the user through systematic debugging processes, including capturing stack traces, isolating failure points, implementing minimal fixes, and providing comprehensive reports detailing the root cause, evidence, specific code patches, and prevention recommendations. Ideal for complex bug resolution and quality assurance.

This skill provides a structured methodology for tackling complex bugs, performance bottlenecks, and production incidents. It guides users through reproducing issues, forming hypotheses, performing controlled experiments, and narrowing down the scope using proven strategies and tools. Ideal for deep dive troubleshooting and root cause analysis in complex software systems.

A comprehensive, expert-level workflow for debugging complex software issues in production environments. This skill guides users through initial triage, advanced observability data collection (APM, distributed traces, logs), intelligent hypothesis generation, and full root cause analysis. Use it when dealing with intermittent failures, performance bottlenecks, or needing a complete fix and prevention plan.

A comprehensive workflow for production-grade, pre-recorded Speech-to-Text (STT) transcription using the Deepgram API. This skill supports transcribing audio from URLs or local files, offering advanced features such as speaker diarization, automatic summaries, sentiment analysis, and topic detection. It also includes robust batch processing methods for handling large datasets.

This skill provides comprehensive methods to optimize Deepgram API usage and manage costs. It implements budget-aware transcription pipelines that preemptively check projected spending against set limits, utilizes audio preprocessing techniques (like silence removal via ffmpeg) to minimize billable minutes, and includes API calls to monitor current usage and spending against defined budgets. Ideal for cost-sensitive, production-grade deployments.

Implements robust Role-Based Access Control (RBAC) for enterprise Deepgram deployments. This skill demonstrates how to map various application roles (Admin, Developer, Analyst, etc.) to specific Deepgram API key scopes. It covers creating scoped keys, managing key lifecycles, and implementing middleware to enforce permissions, ensuring secure, auditable, and granular access control for team-based applications.