grafana-dashboards

Overview of grafana-dashboards skill

What grafana-dashboards does

The grafana-dashboards skill helps an agent design and draft production-style Grafana dashboards for observability work. It is aimed at turning a monitoring goal—like “show API health” or “track infra saturation”—into a sensible dashboard structure with panels, metric groupings, and layout priorities instead of leaving you with a vague prompt and generic chart ideas.

Who should use grafana-dashboards

This skill is best for platform engineers, SREs, DevOps teams, backend engineers, and technical leads building Grafana dashboards for Prometheus-style metrics. It is especially useful when you already know what system you need to observe, but want a cleaner dashboard design based on established monitoring patterns.

The real job-to-be-done

Most users do not need “a dashboard” in the abstract. They need a dashboard that helps operators answer fast questions during incidents, reviews, and routine health checks. The grafana-dashboards skill is most valuable when you want an agent to organize metrics around operational decisions: what is broken, how bad it is, where to look next, and whether it is getting worse.

What makes this skill different

The strongest differentiator in grafana-dashboards is that it anchors dashboard design in observability heuristics rather than pure UI generation. The source emphasizes:

• hierarchy of information
• RED method for services
• USE method for infrastructure and resources

That makes it more useful than a generic “make me a Grafana dashboard” prompt when you care about actionable layout and panel selection, not just JSON output.

What it does not appear to include

This skill is lightweight. From the repository evidence, it mainly provides guidance in SKILL.md and does not include helper scripts, rule files, or support assets. That means grafana-dashboards is best treated as a prompting and design scaffold, not a full dashboard provisioning toolkit.

How to Use grafana-dashboards skill

Install context for grafana-dashboards

If your skills runtime supports adding skills from the repository, install from the wshobson/agents repo and then invoke the grafana-dashboards skill in an observability-oriented workflow. A common pattern is:

npx skills add https://github.com/wshobson/agents --skill grafana-dashboards

If your environment loads the whole repo or syncs skills another way, the important part is that the agent can access the skill at:

plugins/observability-monitoring/skills/grafana-dashboards

Read this file first

Start with:

• plugins/observability-monitoring/skills/grafana-dashboards/SKILL.md

There are no strong signals of companion files for this skill, so nearly all useful guidance appears to live there. This is good for quick adoption, but it also means you should bring your own dashboard schema conventions, datasource details, and export/import workflow.

What input the skill needs from you

The grafana-dashboards skill performs best when you provide operational context, not just a dashboard title. Give the agent:

• the system being monitored
• the audience for the dashboard
• the datasource and metric naming style
• the most important failure modes
• the time horizon and refresh needs
• whether you want service, infrastructure, SLO, or business KPI views

Without that, the agent can still suggest a structure, but panel definitions will be much more generic.

Best-fit dashboard requests

Use grafana-dashboards for requests like:

• API or microservice health dashboards
• Prometheus-backed RED dashboards
• infrastructure dashboards using USE
• SLO and latency-focused observability boards
• production overview dashboards with drill-down sections

It is less suited to one-off ad hoc graphing, custom plugin-heavy Grafana work, or environments where the exact datasource query language matters more than dashboard structure.

Turn a rough request into a strong prompt

Weak prompt:

• “Create a Grafana dashboard for my app.”

Better prompt:

• “Use the grafana-dashboards skill to design a production Grafana dashboard for a customer-facing API. Datasource is Prometheus. Focus on RED metrics, 30s refresh, last 6h by default, and an on-call audience. Include top-row stat panels for traffic, error rate, p95 latency, and saturation signals. Then propose panel titles, layout order, and example PromQL queries.”

Why this works:

• it names the system
• it picks a design method
• it sets audience and time window
• it asks for structure and queries
• it gives the agent enough constraints to avoid generic output

Prompt template for grafana-dashboards usage

You can adapt this template:

• “Use the grafana-dashboards skill to design a Grafana dashboard for [service/system].
• Audience: [on-call / engineering managers / platform team]
• Datasource: [Prometheus / other]
• Dashboard goal: [incident response / daily health review / SLO tracking]
• Key metrics: [request rate, error rate, p95 latency, CPU saturation, queue depth]
• Default time range: [1h / 6h / 24h]
• Refresh interval: [15s / 30s / 1m]
• Constraints: [must fit single screen / include variables / separate business KPIs from infra]
• Output wanted: [panel plan / Grafana JSON draft / PromQL suggestions / layout rationale]”

Suggested workflow in practice

A good grafana-dashboards usage flow is:

1. Define the dashboard purpose in one sentence.
2. Choose the lens: RED, USE, SLO, or KPI-focused.
3. List the exact metrics available in your datasource.
4. Ask the agent for panel hierarchy first.
5. Ask for example queries second.
6. Review gaps against your real labels and metric names.
7. Only then ask for Grafana JSON or provisioning output.

This order avoids a common failure mode where the agent invents polished but unusable dashboard JSON before the metric model is validated.

Design patterns surfaced by the skill

The source material highlights a few practical patterns worth preserving:

• place critical metrics first as big-number or stat panels
• use time series for trend visibility
• push detailed diagnostics lower in the dashboard
• use RED for service behavior
• use USE for hosts, nodes, disks, queues, and similar resources

For observability teams, this is the main value of the grafana-dashboards skill: it improves decision flow, not just chart count.

What the output will likely look like

Based on the repository, expect the skill to help produce:

• dashboard section plans
• panel ordering recommendations
• metric category suggestions
• JSON-like dashboard examples
• monitoring-method-driven panel choices

Do not expect turnkey correctness for your exact labels, recording rules, folder structure, permissions, or Grafana provisioning setup unless you provide those details explicitly.

Practical tips that change output quality

For better grafana-dashboards usage, always include:

• real metric names if you have them
• whether percentiles are available
• cardinality constraints
• environment filters like cluster, namespace, or service
• whether the dashboard is for overview or deep debugging

These details materially change whether the agent proposes useful top panels, realistic variables, and sane query scopes.

grafana-dashboards skill FAQ

Is grafana-dashboards good for beginners?

Yes, if you already know the basics of Grafana and metrics. The grafana-dashboards skill gives a good structure for what to show first and how to group panels. It is less effective as a full beginner tutorial on Prometheus, Grafana provisioning, or query language fundamentals.

Does grafana-dashboards create real Grafana JSON?

It can guide or draft JSON-shaped output, but you should treat the result as a starting point. You will still need to validate panel types, datasource UIDs, query syntax, variables, and Grafana version compatibility in your own environment.

Is this better than an ordinary prompt?

Usually yes, for observability work. The value of grafana-dashboards is that it narrows the agent toward proven dashboard design patterns like RED, USE, and information hierarchy. A generic prompt often produces dashboards that look busy but do not support fast operational reading.

When should I not use grafana-dashboards?

Skip it when your problem is mainly:

• fixing broken PromQL
• managing Grafana provisioning pipelines
• building custom panels or plugins
• reverse-engineering an exported dashboard
• handling datasource-specific quirks without a standard observability layout problem

In those cases, a more specialized skill or direct repository-specific prompt is usually better.

Does grafana-dashboards work only for Prometheus?

No, but it is most naturally aligned with Prometheus-style observability concepts. If you use another datasource, be explicit about query language, supported panel types, and field names so the agent does not assume PromQL conventions.

Is grafana-dashboards for Observability teams only?

No. It also fits product and engineering teams that need business KPI or service-health dashboards, as long as the goal is structured operational visibility. The skill is simply strongest when the dashboard needs clear monitoring logic, not just executive reporting aesthetics.

How to Improve grafana-dashboards skill

Give the agent your metric inventory first

The fastest way to improve grafana-dashboards results is to provide a short metric inventory before asking for a dashboard. Even 10 to 15 real metrics is enough to stop the agent from inventing names and to make panel planning much more deployable.

State the operator question the dashboard must answer

Better dashboards come from questions, not chart lists. Examples:

• “Can on-call tell in 30 seconds whether the API is broken?”
• “Can we detect CPU saturation before latency rises?”
• “Can product and ops review revenue-impacting errors in one view?”

This sharpens what belongs in the top row versus lower diagnostic sections.

Separate overview panels from debugging panels

A common failure mode in grafana-dashboards usage is overloading the first screen. Ask the agent to split the output into:

• executive or on-call summary
• trend section
• drill-down or detailed diagnostics

That creates a dashboard people can actually scan under pressure.

Tell it which method to use

Do not assume the agent will choose the right monitoring model. Say explicitly:

• use RED for request-driven services
• use USE for compute or infrastructure
• combine SLO panels with RED for customer-facing APIs

This single instruction often improves panel relevance more than asking for “best practices.”

Ask for rationale, not just output

If the first draft looks plausible but generic, ask:

• why each top panel earned its position
• what panel can be removed if screen space is limited
• which metrics are leading indicators versus lagging indicators

That forces the grafana-dashboards skill to produce a more defensible design instead of decorative completeness.

Correct the first draft with concrete constraints

Iteration works best when your feedback is specific:

• “We do not have histogram buckets.”
• “Use namespace and pod variables.”
• “This dashboard is for mobile backend only.”
• “Remove business KPIs; this is strictly incident response.”
• “Keep it to one screen for a NOC display.”

Concrete constraints usually improve the second pass dramatically.

Watch for common weak-output signs

Be cautious if the draft:

• uses generic metric names you do not have
• places too many tables above time series
• mixes service and infrastructure concerns without separation
• lacks a clear top-row summary
• ignores audience and default time range

These are signs the skill was invoked with too little context or too broad a request.

Improve grafana-dashboards with repository-aware usage

Because this skill appears to rely mainly on SKILL.md, you can improve practical results by pairing it with your own local standards:

• your Grafana JSON schema examples
• your naming conventions
• your PromQL snippets
• your folder and templating rules

In practice, grafana-dashboards is strongest as the design brain, while your own environment provides the implementation details.