OpenTelemetry Skills for AI Coding Agents

Vendor-neutral skills that teach AI coding agents how to instrument applications with OpenTelemetry. Covers SDK setup across languages, semantic conventions, Collector pipelines, and OTTL transformations. Works with any OTLP-compatible backend.

Skills are packaged instructions and scripts that extend agent capabilities, following the Agent Skills format. Maintained by Dash0.

[!TIP] These skills have been improved using Tessl. Try it out for your own agent skills, it's worth it.

Why vendor-neutral OpenTelemetry

These skills are built around the OpenTelemetry specification, not any single backend. The output is standard OTLP telemetry that any OpenTelemetry-compatible backend can ingest.

Vendor lock-in in observability comes from proprietary agents and attribute schemas. Skills in this repository avoid both: they guide agents to use OpenTelemetry SDKs and the OpenTelemetry Collector, and to follow the upstream Semantic Conventions for attribute, span, and metric naming.

Why semantic conventions matter

OpenTelemetry Semantic Conventions define standardized names, types, and semantics for telemetry attributes, metric names, span names, and status codes. Following them is the single highest-leverage thing you can do for observability quality.

When instrumentation follows semantic conventions:

• Auto-instrumentation libraries, dashboards, and alerting rules work out of the box.
• Service maps, operation grouping, and error tracking derive correct results without manual configuration.
• Cross-service queries return consistent results because every service speaks the same attribute language.

When conventions are missing or inconsistent, these capabilities degrade silently: no errors, just incomplete data, broken topology views, and fragmented queries.

Instrumentation score

Guidance in these skills aligns with the Instrumentation Score specification, a vendor-neutral corpus of guidance that quantifies how well a service follows OpenTelemetry best practices. The spec defines impact-weighted rules across resources, spans, metrics, and logs. Following this guidance helps your services score higher, which means better observability outcomes downstream.

Automation with Claude Code

You can configure Claude Code to apply these skills automatically, both in interactive sessions and in headless CI/CD pipelines.

Project instructions via CLAUDE.md

Add a CLAUDE.md file to your repository root with instructions that tell Claude Code when to use the skills. Claude Code loads this file at the start of every session.

# Observability

This project uses OpenTelemetry for observability.
When adding or modifying instrumentation, follow the guidance from the installed `dash0hq/agent-skills` skills.

When working on application code or deployment specs, use the `otel-instrumentation` skill.
When working on Collector configuration, use the `otel-collector` skill.
When choosing or reviewing telemetry attributes, use the `otel-semantic-conventions` skill.
When writing or debugging OTTL expressions, use the `otel-ottl` skill.

Headless mode in CI/CD

Use claude -p to run Claude Code non-interactively in a pipeline. This enables automated instrumentation reviews, skill-guided code generation, and PR checks.

# Review instrumentation quality on a pull request
claude -p "Review the OpenTelemetry instrumentation changes in this PR. \
  Check for missing context propagation, incorrect span status handling, \
  and semantic convention violations." \
  --allowedTools "Read,Grep,Glob"

GitHub Actions example

name: Instrumentation review

on: [pull_request]

jobs:
  review:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Install skills
        run: npx skills add dash0hq/agent-skills

      - name: Review instrumentation
        run: |
          claude -p "Review the OpenTelemetry instrumentation in this PR \
            for correctness and semantic convention compliance. \
            Post your findings as a summary." \
            --allowedTools "Read,Grep,Glob" \
            --output-format json > review.json

      - name: Comment on PR
        run: |
          findings=$(jq -r '.result' review.json)
          gh pr comment "$PR_NUMBER" --body "## Instrumentation review"$'\n\n'"$findings"
        env:
          PR_NUMBER: ${{ github.event.pull_request.number }}

Installation

Install with skills CLI (universal, works with any Agent Skills-compatible tool):

npx skills add https://github.com/dash0hq/agent-skills --all
# or a single skill:
npx skills add https://github.com/dash0hq/agent-skills --skill otel-semantic-conventions

For tool-specific installation instructions (Claude Code, Cursor, Tessl, and others), see INSTALL.md.

How to use

Once installed, skills load automatically and the agent picks them up when a task matches.

Examples:

Add OpenTelemetry instrumentation to my app

My traces are broken — spans show up as separate roots instead of a connected trace

Set up an OpenTelemetry Collector pipeline that forwards to Dash0

Write an OTTL expression to redact credit card numbers from log bodies

Ensure that my HTTP server spans have the correct attributes

Help me fix high-cardinality metrics that are blowing up my costs