deepgram-rate-limits
Implement Deepgram rate limiting and backoff strategies. Use when handling API quotas, implementing request throttling, or dealing with 429 rate limit errors. Trigger: "deepgram rate limit", "deepgram throttling", "429 error deepgram", "deepgram quota", "deepgram backoff", "deepgram concurrency".
68
83%
Does it follow best practices?
Impact
—
No eval scenarios have been run
Passed
No known issues
Quality
Discovery
89%Based on the skill's description, can an agent find and select it at the right time? Clear, specific descriptions lead to better discovery.
This is a well-structured skill description with strong trigger terms and clear 'what/when' guidance. Its main weakness is that the capability description could be more specific about the concrete actions involved (e.g., exponential backoff configuration, retry logic, concurrency limits). The explicit trigger term list and 'Use when' clause make it highly effective for skill selection.
Suggestions
Expand the capability description with more concrete actions, e.g., 'Implement exponential backoff, configure retry logic, set concurrency limits, and handle 429 responses for Deepgram API calls.'
| Dimension | Reasoning | Score |
|---|---|---|
Specificity | Names the domain (Deepgram rate limiting) and some actions (rate limiting, backoff strategies), but doesn't list multiple concrete implementation actions like 'configure retry delays, set max concurrent requests, implement exponential backoff, handle 429 responses'. | 2 / 3 |
Completeness | Clearly answers both 'what' (implement Deepgram rate limiting and backoff strategies) and 'when' (handling API quotas, request throttling, 429 rate limit errors) with an explicit 'Use when' clause and explicit trigger terms. | 3 / 3 |
Trigger Term Quality | Excellent coverage of natural trigger terms including 'deepgram rate limit', '429 error deepgram', 'deepgram throttling', 'deepgram quota', 'deepgram backoff', and 'deepgram concurrency' — these are terms users would naturally use when encountering these issues. | 3 / 3 |
Distinctiveness Conflict Risk | Highly distinctive — the combination of 'Deepgram' with rate limiting/backoff creates a very specific niche that is unlikely to conflict with generic rate limiting skills or other Deepgram skills focused on different functionality. | 3 / 3 |
Total | 11 / 12 Passed |
Implementation
77%Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.
This is a strong, actionable skill with fully executable TypeScript examples that address a specific and non-obvious aspect of Deepgram's API (concurrency-based rate limiting). The workflow builds logically from simple to complex patterns with good error handling guidance. The main weakness is length — the inline code is extensive and some patterns (circuit breaker) are generic enough to be summarized or extracted to supporting files.
Suggestions
Extract the circuit breaker implementation (Step 3) into a separate bundle file and reference it from SKILL.md, keeping only the usage pattern inline.
Trim the RetryableDeepgramClient code by removing verbose comments and condensing the retry loop, since Claude understands exponential backoff patterns.
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | The skill is mostly efficient and provides Deepgram-specific knowledge Claude wouldn't have (concurrency model, plan limits), but the code examples are quite lengthy. The circuit breaker pattern is a well-known concept that could be more concise, and the combined client in Step 4 largely repeats what was already shown. The table of plan limits and error handling table add value though. | 2 / 3 |
Actionability | All code examples are fully executable TypeScript with proper imports, concrete API calls using the Deepgram SDK, and realistic usage patterns. The examples are copy-paste ready with clear constructor parameters, error handling, and production usage demonstrations. | 3 / 3 |
Workflow Clarity | The steps are clearly sequenced from basic concurrency limiting (Step 1) through retry logic (Step 2), circuit breaker (Step 3), combined pattern (Step 4), and monitoring (Step 5). Each step builds on the previous one, and validation/error recovery is built into the patterns themselves (retry loops, circuit breaker state transitions, error classification for retryable vs non-retryable). | 3 / 3 |
Progressive Disclosure | The content is well-structured with clear sections and a summary table, but it's a long monolithic file (~200 lines of code) with no bundle files to offload detail. The circuit breaker and retry client implementations could be referenced as separate files, keeping SKILL.md as an overview with the concurrency queue and combined usage pattern. | 2 / 3 |
Total | 10 / 12 Passed |
Validation
81%Checks the skill against the spec for correct structure and formatting. All validation checks must pass before discovery and implementation can be scored.
Validation — 9 / 11 Passed
Validation for skill structure
| Criteria | Description | Result |
|---|---|---|
allowed_tools_field | 'allowed-tools' contains unusual tool name(s) | Warning |
frontmatter_unknown_keys | Unknown frontmatter key(s) found; consider removing or moving to metadata | Warning |
Total | 9 / 11 Passed | |
- Commit
70e07c0
- Reviewed
Table of Contents
Is this your skill?
If you maintain this skill, you can claim it as your own. Once claimed, you can manage eval scenarios, bundle related skills, attach documentation or rules, and ensure cross-agent compatibility.