gamma-observability
Implement comprehensive observability for Gamma integrations. Use when setting up monitoring, logging, tracing, or building dashboards for Gamma API usage. Trigger with phrases like "gamma monitoring", "gamma logging", "gamma metrics", "gamma observability", "gamma dashboard".
80
77%
Does it follow best practices?
Impact
Pending
No eval scenarios have been run
Passed
No known issues
Optimize this skill with Tessl
npx tessl skill review --optimize ./plugins/saas-packs/gamma-pack/skills/gamma-observability/SKILL.mdQuality
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 solid skill description that clearly identifies its niche (Gamma observability) and provides explicit trigger guidance. Its main weakness is that the capability description stays at a high level (monitoring, logging, tracing, dashboards) without drilling into specific concrete actions. The explicit trigger phrases and 'Use when' clause make it highly functional for skill selection.
Suggestions
Add more specific concrete actions beyond high-level categories, e.g., 'configure alert rules, set up distributed tracing, create metric dashboards, aggregate API logs, track error rates and latency for Gamma endpoints'.
| Dimension | Reasoning | Score |
|---|---|---|
Specificity | The description names the domain (observability for Gamma integrations) and mentions some actions (monitoring, logging, tracing, building dashboards), but these are fairly high-level categories rather than multiple specific concrete actions like 'configure alert thresholds, set up distributed tracing spans, create Grafana dashboards'. | 2 / 3 |
Completeness | The description clearly answers both 'what' (implement comprehensive observability for Gamma integrations) and 'when' (explicit 'Use when' clause for monitoring, logging, tracing, dashboards, plus explicit trigger phrases). Both components are present and explicit. | 3 / 3 |
Trigger Term Quality | The description explicitly lists natural trigger phrases users would say: 'gamma monitoring', 'gamma logging', 'gamma metrics', 'gamma observability', 'gamma dashboard'. It also includes related terms like 'tracing' and 'Gamma API usage', providing good coverage of natural terms. | 3 / 3 |
Distinctiveness Conflict Risk | The combination of 'Gamma' as a specific platform/API with 'observability' creates a clear niche. The trigger terms are all prefixed with 'gamma', making it unlikely to conflict with generic monitoring skills or other platform-specific skills. | 3 / 3 |
Total | 11 / 12 Passed |
Implementation
64%Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.
This is a solid, highly actionable skill with complete executable code for Gamma API observability. Its main weakness is length — the full code implementations make it token-heavy, and the workflow lacks explicit validation checkpoints between steps (e.g., verifying metrics are being collected before setting up alerts). The error handling table and key metrics table are excellent additions that add practical value.
Suggestions
Add validation checkpoints between steps, e.g., 'After Step 1, verify metrics by calling getMetrics() and confirming requests increment' and 'After Step 4, confirm /metrics/gamma returns valid Prometheus format before configuring alerting rules'.
Consider moving the full instrumented client code (Step 1) to a referenced file and keeping only the key interface and getMetrics() function inline to reduce token usage.
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | The skill provides substantial executable code which is valuable, but is quite long (~200 lines). Some sections like the Prometheus metrics endpoint and alerting rules could be more condensed. The overview appropriately explains why observability is client-side (no rate limit headers), which is useful context, but the overall content could be tightened. | 2 / 3 |
Actionability | Fully executable TypeScript code throughout, with concrete implementations for an instrumented client, structured logging, health check endpoint, Prometheus metrics endpoint, and alerting rules in YAML. All code is copy-paste ready with specific API paths, metric names, and threshold values. | 3 / 3 |
Workflow Clarity | Steps are clearly numbered and sequenced (1-5), building logically from instrumented client to alerting. However, there are no explicit validation checkpoints between steps — no guidance on verifying the instrumented client works before moving to logging, or confirming metrics appear in Prometheus before setting up alerts. For a multi-step observability setup, verification steps would prevent cascading misconfigurations. | 2 / 3 |
Progressive Disclosure | The skill references external resources (Prometheus docs, Grafana docs, gamma-sdk-patterns, gamma-incident-runbook) which is good. However, the inline content is quite long with full code blocks that could potentially be split into referenced files. The summary tables at the end are well-organized, but the main body is somewhat monolithic. | 2 / 3 |
Total | 9 / 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
3e83543
- 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.