Skip to main content
skill CX Codex

alerting-dashboard-builder — Claude Code skill

alerting-dashboard-builder turns your service level objectives into Prometheus burn-rate alerts and a dashboard template, with runbook links and a first-response guide.

MIT 266 installs ★ 64 updated 2026-01-12

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add patricio0312rev/skills --skill alerting-dashboard-builder -a claude-code
Open on GitHub

What alerting-dashboard-builder does

The skill gives you a starting set for service monitoring: SLOs written as YAML with an objective, a window and an SLI, Prometheus alert rules, and a JSON dashboard template. Three parts sit inside. One holds the SLO block with PromQL expressions, another the rules for fast and slow error-budget burn, the third a row of golden-signal panels covering request rate, errors, latency percentiles, CPU and memory.

Alerts carry a severity label. One fires when 1% of the budget burns within an hour; the warning rule catches a slower burn measured over a day. Both use for so a brief spike does not page anyone, and both attach a runbook annotation. That link, https://runbooks.example.com/availability-fast-burn, is a placeholder — swap in your own URL or the on-call engineer lands on a dead page.

Queries assume the metric names http_requests_total and http_request_duration_seconds_bucket. Different names in your setup mean rewriting the expressions, otherwise panels and alerts stay empty. A short response guide is included too: check the latest deploy, read the error logs, look at dependent services, escalate after 15 minutes.

What it helps with

  • define an SLO with objective, window and SLI in YAML
  • generate Prometheus rules for fast and slow error-budget burn
  • lay out a dashboard with golden-signal and SLO-tracking panels
  • attach a runbook link to an alert annotation
  • write down first-response steps for a high error rate or high latency

Example prompts for the agent

  • Define an SLO for our API: 99.9% availability over 30d and p95 latency under 500ms, then write the alert rules.
  • Build a service health dashboard with golden-signal panels and an error budget row.
  • Add a runbook link and a first-response guide to the AvailabilitySLOFastBurn alert.

How to install alerting-dashboard-builder

1Skills CLI (Vercel)

npx skills add patricio0312rev/skills --skill alerting-dashboard-builder -a claude-code

2Manually: put the files in place

~/.claude/skills/alerting-dashboard-builder/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/alerting-dashboard-builder/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about alerting-dashboard-builder

How to install alerting-dashboard-builder in Claude Code?

Run npx skills add patricio0312rev/skills --skill alerting-dashboard-builder -a claude-code. The skill file lands at ~/.claude/skills/alerting-dashboard-builder/SKILL.md.

What does alerting-dashboard-builder do?

It defines SLOs in PromQL, writes Prometheus alert rules for error-budget burn, and produces a dashboard template with key charts. Each alert gets a runbook annotation and a short response guide.

Which metrics do the queries rely on?

The expressions use http_requests_total and http_request_duration_seconds_bucket. With different metric names you will need to rewrite the queries before the panels and alerts return anything.

Source text

SKILL.md · MIT
---
name: alerting-dashboard-builder
description: Creates SLO-based alerts and operational dashboards with key charts, alert thresholds, and runbook links. Use for "alerting", "dashboards", "SLO", or "monitoring".
---

# Alerting & Dashboard Builder

Build effective alerts and dashboards based on SLOs.

## SLO Definition

```yaml
slos:
  - name: api_availability
    objective: 99.9%
    window: 30d
    sli: |
      sum(rate(http_requests_total{status_code!~"5.."}[5m])) /
      sum(rate(http_requests_total[5m]))

  - name: api_latency
    objective: 95% # 95% of requests under 500ms
    window: 30d
    sli: |
      histogram_quantile(0.95,
        rate(http_request_duration_seconds_bucket[5m])
      ) < 0.5
```

## Alert Rules

```yaml
groups:
  - name: slo_alerts
    rules:
      # Fast burn (1% budget in 1h)
      - alert: AvailabilitySLOFastBurn
        expr: |
          (1 - (sum(rate(http_requests_total{status_code!~"5.."}[1h])) /
          sum(rate(http_requests_total[1h])))) > 0.01
        for: 5m
        labels:
          severity: critical
        annotations:
          summary: "Burning 1% error budget per hour"
          runbook: "https://runbooks.example.com/availability-fast-burn"

      # Slow burn (10% budget in 24h)
      - alert: AvailabilitySLOSlowBurn
        expr: |
          (1 - (sum(rate(http_requests_total{status_code!~"5.."}[24h])) /
          sum(rate(http_requests_total[24h])))) > 0.001
        for: 1h
        labels:
          severity: warning
        annotations:
          summary: "Burning error budget slowly"
```

## Dashboard Template

```json
{
  "title": "Service Health Dashboard",
  "rows": [
    {
      "title": "Golden Signals",
      "panels": [
        {
          "title": "Request Rate",
          "query": "sum(rate(http_requests_total[5m]))",
          "type": "graph"
        },
        {
          "title": "Error Rate",
          "query": "sum(rate(http_requests_total{status_code=~"5.."}[5m]))",
          "type": "graph"
        },
        {
          "title": "Latency (p50, p95, p99)",
          "queries": [
            "histogram_quantile(0.50, rate(http_request_duration_seconds_bucket[5m]))",
            "histogram_quantile(0.95, rate(http_request_duration_seconds_bucket[5m]))",
            "histogram_quantile(0.99, rate(http_request_duration_seconds_bucket[5m]))"
          ]
        },
        {
          "title": "Saturation (CPU, Memory)",
          "queries": [
            "rate(process_cpu_seconds_total[5m])",
            "process_resident_memory_bytes"
          ]
        }
      ]
    },
    {
      "title": "SLO Tracking",
      "panels": [
        {
          "title": "Error Budget Remaining",
          "query": "1 - ((1 - 0.999) - (1 - slo_availability))"
        }
      ]
    }
  ]
}
```

## What to Do When Alert Fires

```markdown
# Alert Response Guide

## HighErrorRate

**What it means:** More than 5% of requests are failing

**First steps:**

1. Check recent deployments (rollback if needed)
2. Review error logs for patterns
3. Check dependent services health
4. Verify database connectivity

**Escalation:** If not resolved in 15 min, page on-call lead

## HighLatency

**What it means:** p95 latency above 2 seconds

**First steps:**

1. Check database query performance
2. Review recent code changes
3. Check cache hit rates
4. Look for slow external API calls

**Temporary mitigation:**

- Scale up instances
- Enable aggressive caching

## LowAvailability

**What it means:** Availability below 99.5%

**First steps:**

1. Check infrastructure (AWS status page)
2. Review load balancer health checks
3. Check for DDoS activity
4. Verify auto-scaling functioning
```

## Output Checklist

- [ ] SLOs defined
- [ ] Alert rules configured
- [ ] Dashboards created
- [ ] Runbooks linked
- [ ] Response guides documented
      ENDFILE

© patricio0312rev · MIT · patricio0312rev/skills

Similar skills

All skills for DevOps and infrastructure →

From the same set148

The whole set →
tech-debt-prioritizer The tech-debt-prioritizer skill scores technical debt by impact, risk, and effort, then ranks the work. Use it to decide which codebase issues to tackle first. CX Codex +1 268installs integration-test-builder integration-test-builder — a skill for building integration tests for APIs and database flows. Generates test harness, fixtures, setup/teardown, database seeding, and CI-ready strategies. CX Codex +1 267installs tanstack-query-setup tanstack-query-setup sets up TanStack Query in a React app: a QueryClient provider, fetch hooks, mutations and cache rules. The agent gets templates it can fill with your code. CX Codex +1 267installs hot-reload-optimizer The hot-reload-optimizer skill for Claude Code fine-tunes hot module replacement and fast refresh in Vite, Next.js, and webpack projects when local rebuilds lag. CX Codex +1 267installs contract-testing-builder contract-testing-builder implements API contract testing with Pact, OpenAPI, and JSON Schema to catch breaking changes before deploying services. CX Codex +1 266installs rollback-workflow-builder rollback-workflow-builder builds deployment rollback workflows, runbooks, and recovery checks. Use it for production incidents or automatic recovery after a failed release. CX Codex +1 266installs vector-db-setup vector-db-setup sets up vector databases like Pinecone and Chroma with OpenAI embedding pipelines and similarity search queries for AI apps. CX Codex +1 266installs capacity-planning-helper capacity-planning-helper is a Claude Code skill that turns a traffic forecast into instance counts, database and cache sizing, and a monthly AWS cost estimate. CX Codex +1 265installs

Project sponsors

Companies that keep this analytics open