create-honeycomb-board — Claude Code skill: what it does
create-honeycomb-board turns a service, a feature or an incident into a Honeycomb board: gathers SLOs, tests candidate queries, lays out panels and creates it through MCP tools.
MIT 111 installs ★ 28 updated 2026-10-09
npx skills add honeycombio/agent-skill --skill create-honeycomb-board -a claude-codeWhat create-honeycomb-board does
The skill builds a Honeycomb board using the Honeycomb MCP tools. It reads the SLOs in your environment first, then goes through code and docs (Read, Grep, Glob) to write a text panel with a link to the repo. After that it looks at dataset columns and at queries people already ran. Candidate graphs arrive as a list with reasons attached, and nothing is executed until you have seen it.
Each query run hands back an id like QR-abc123, which becomes the panel id. Panels sit on a 12-column grid: stat panels fit side by side, a heatmap gets the full width. The starting time range is 2 hours; the skill suggests 8–24 hours for low-volume services and 7 days for feature boards. Aim for 6–12 graphs.
A board cannot be edited once it exists. The only fix is to delete it and build again, which is why the plan gets shown before creation — a request to skip the preview does not skip it. A Honeycomb MCP server with the mcp__honeycomb__* tools has to be configured, or there is nothing to call.
What it helps with
- build a service health board from existing SLOs and queries
- pick dataset columns for breakdowns on custom attributes
- test candidate queries and drop the ones returning nothing useful
- lay panels out on a 12-column grid
- add preset filters so viewers can slice by route or region
Example prompts for the agent
- Build a health board for the checkout service with SLOs, request rate and latency.
- Make a dashboard for feature usage over the last week.
- Set up a monitoring board for this incident and include the patterns to look for.
How to install create-honeycomb-board
1Skills CLI (Vercel)
npx skills add honeycombio/agent-skill --skill create-honeycomb-board -a claude-code2Manually: put the files in place
~/.claude/skills/create-honeycomb-board/SKILL.mdCopy the whole skill folder; for one project use .claude/skills/create-honeycomb-board/
1Skills CLI (Vercel)
npx skills add honeycombio/agent-skill --skill create-honeycomb-board -a codex2Manually: put the files in place
.agents/skills/create-honeycomb-board/SKILL.mdFor all projects use ~/.agents/skills/
1Skills CLI (Vercel)
npx skills add honeycombio/agent-skill --skill create-honeycomb-board -a cursor2Manually: put the files in place
.cursor/skills/create-honeycomb-board/SKILL.mdCursor also reads .agents/skills/ and .claude/skills/
1GitHub CLI
gh skill install honeycombio/agent-skill honeycomb/skills/create-honeycomb-board2Manually: put the files in place
.github/skills/create-honeycomb-board/SKILL.md1Skills CLI (Vercel)
npx skills add honeycombio/agent-skill --skill create-honeycomb-board -a gemini-cli2Platform CLI
gemini skills install https://github.com/honeycombio/agent-skill --path honeycomb/skills/create-honeycomb-boardManually: put the files in place
.devin/skills/create-honeycomb-board/SKILL.mdThe legacy .windsurf/skills/ path still works
Skills CLI (Vercel)
npx skills add honeycombio/agent-skill --skill create-honeycomb-board -a opencodeClaude.ai
Zip the folder and upload it in Settings → Capabilities → Skills
Step by step, with commands for each platform: How to install skills in Claude Code: five ways
Questions about create-honeycomb-board
How do I install create-honeycomb-board in Claude Code?
Run npx skills add honeycombio/agent-skill --skill create-honeycomb-board -a claude-code. The skill file lands at ~/.claude/skills/create-honeycomb-board/SKILL.md.
What does create-honeycomb-board do?
It designs and creates a Honeycomb board: collects SLOs, runs queries, arranges panels and calls create_board.
Does it work without the Honeycomb MCP server?
No. The skill acts through the mcp__honeycomb__* tools such as create_board, run_query and get_slos, so that server has to be set up first.
Source text
SKILL.md · MIT
---
name: create-honeycomb-board
description: >
Design and create a Honeycomb board (dashboard) with queries and SLOs. Trigger phrases:
"make a board", "build a dashboard", "create a Honeycomb board", "make a dashboard in
Honeycomb", "set up a board", "dashboard for my service", "visualize service health",
"golden signals dashboard", "set up monitoring board".
metadata:
version: "1.0.0"
allowed-tools:
- mcp__honeycomb__create_board
- mcp__honeycomb__run_query
- mcp__honeycomb__get_query_results
- mcp__honeycomb__get_workspace_context
- mcp__honeycomb__get_environment
- mcp__honeycomb__get_dataset
- mcp__honeycomb__get_dataset_columns
- mcp__honeycomb__find_columns
- mcp__honeycomb__find_queries
- mcp__honeycomb__get_slos
- mcp__honeycomb__get_triggers
- mcp__honeycomb__list_boards
- Read
- Grep
- Glob
- AskUserQuestion
---
# Create a Honeycomb Board
Build a board (dashboard) in Honeycomb using the `create_board` MCP tool.
There is no update tool — define it well before creating.
When building a board, think about the purpose and time frame involved. Some examples:
- a board for a service. This should be timeless, looking at the service's health, performance, and business metrics. Do not do any problem diagnosis or investigation when building this board. Do not express opinions or summarize graphs in text panels. The board should be a representation of the service's health at whatever moment someone looks at it.
- a board for a feature. This should look at the feature's usage trends, and its impact on the business. This board would have a time frame of 7 days, and would not include any infrastructure metrics or service dependencies.
- a board for a problem. This might be created during an incident, or afterward. This one would have a time frame specific to the incident. It would include investigations, and your opinions about what is happening. Patterns of what to look for are appropriate here.
## Workflow
### Gather SLOs
Use `get_slos` to list SLOs in the environment. Relevant SLOs will go on the board as `slo` panels.
### Gather descriptive context
Look at the code and docs (using Read/Grep/Glob) to understand the service or feature. Use this to write a text panel. Link to GitHub or documentation if you can.
This will vary greatly depending on the purpose of the board.
Description of the application and link to the code - great for a service board.
What is the feature, and what business impact does it have? - great for a feature board.
What is the problem, and what is the impact? What patterns do we see? - great for a problem board.
### Build candidate queries
**Get Honeycomb context**: Call `get_workspace_context` for available environments. Use `get_environment` to find datasets — each dataset corresponds to an `OTEL_SERVICE_NAME`.
**Code context**: Look at the language and any custom attributes (often prefixed `app.`). Custom fields are prime candidates for breakdowns and business metrics.
**Discover columns**: Use `find_columns` or `get_dataset_columns`. Pay special attention to non-standard columns — those are specific to the application.
**Find queries**: Use `find_queries` to see what people have already queried. Check `get_triggers` for what they alert on — those indicate what matters.
**Time range**: Default to 2 hours. Use 8–24 hours for lower-volume services. Use 7 days for feature usage boards. Keep it consistent across all panels.
Aim for 6–12 graphs. Stat panels are bonus — they don't count against this limit.
List your candidate queries for the user with reasons before running them. See `${CLAUDE_PLUGIN_ROOT}/skills/create-honeycomb-board/references/board-queries.md` for what to include and how to write each kind.
### Run and check queries
Use `run_query` for each candidate query. Each result returns a query run PK (like `QR-abc123`) — you'll use this as the panel `id` when building the board.
Fix errors. Eliminate queries that return no interesting results.
### Plan the layout
Think about visual flow and how to make the board expressive. The board uses a 12-column grid — stat panels can sit side-by-side, a heatmap deserves full width, breakdowns benefit from extra height. See `${CLAUDE_PLUGIN_ROOT}/skills/create-honeycomb-board/references/board-layout.md` for sizing examples.
Consider `preset_filters` if viewers will want to slice the board interactively (by route, region, account tier, etc.).
### Show the proposed board to the user — always, without exception
For each panel, display:
- **Text panels**: Show the **full markdown content** that will appear on the board. The user needs to review the exact wording before creation since boards can't be updated.
- **SLO panels**: Show the SLO name, target, and current compliance.
- **Query panels**: Show the name, description, chart type, display style, and a **link to the query** (the `query_url` from the run_query result metadata). Briefly describe what the results showed.
- Planned layout (sizing and groupings)
- **Tags**: Display the tags you plan to add to the board.
- Any preset filters
End with: "Here's the board I'd create. Shall I go ahead?"
**This step is non-negotiable.** If the user says "just create it", "I trust you", or "skip the preview" — show the plan anyway. The user cannot meaningfully confirm something they haven't seen. There is no way to update a board after creation; the only fix is to delete it and start over. Showing the plan first protects them even when they think they don't need it.
The one exception: if the user has already reviewed and approved a specific plan in this conversation, you may proceed.
### Create the board
Call `create_board` with a `panels` array. Every panel requires a `type` field — `"query"`, `"slo"`, or `"text"` — that determines what other fields apply. See `${CLAUDE_PLUGIN_ROOT}/skills/create-honeycomb-board/references/board-layout.md` for the full field reference.
```json
{
"environment_slug": "production",
"name": "Checkout Service",
"description": "...",
"panels": [
{
"type": "text",
"content": "## Checkout Service\nOwned by Platform team. [Source](https://github.com/...)"
},
{
"type": "slo",
"id": "SLO-abc123",
"size": { "width": 4 }
},
{
"type": "query",
"id": "QR-abc123",
"name": "Request Rate",
"chart_type": "stat",
"display_style": "chart",
"size": { "width": 4 }
},
{
"type": "query",
"id": "QR-def456",
"name": "Error Rate",
"chart_type": "stat",
"display_style": "chart",
"size": { "width": 4 }
},
{
"type": "query",
"id": "QR-ghi789",
"name": "Latency Distribution",
"description": "Overall request latency as a heatmap",
"chart_type": "default",
"display_style": "chart",
"size": { "width": 12, "height": 3 }
}
],
"preset_filters": [{ "column": "http.route", "alias": "Route" }],
"tags": ["team:platform", "tier:critical"]
}
```
### Follow up
Link the user to the board.
## Cross-References
- For query construction patterns and calculated fields: **query-patterns** skill
- For SLO interpretation and burn alert design: **slos-and-triggers** skill
© honeycombio · MIT · honeycombio/agent-skill