# Teach Your Coding Agent OpenTelemetry We’re releasing our Agent Skills for OpenTelemetry as a mature, open source set: 14 skills that give any coding agent accurate, current OpenTelemetry knowledge. Published: 2026-07-14 Canonical URL: https://ollygarden.com/resources/blog/teach-your-coding-agent-opentelemetry More of the code running in production today was written by a coding agent than a year ago, and next year that share will be larger still. We see no sign of this trend slowing down; if anything, it is accelerating. This changes something fundamental about telemetry. When agents write the code and agents help operate it, telemetry stops being something humans occasionally glance at on a dashboard. It becomes the primary source of truth that agents use to understand what is actually happening in a running system. That world breaks down quickly when telemetry is high volume and low quality. The observability backend bill becomes prohibitive: ingestion and storage costs grow with every span nobody needed, and query costs compound on top, because agents query telemetry far more often and far more broadly than humans ever did. Agents reasoning over noisy signals reach wrong conclusions with full confidence. And incidents take longer to resolve, for humans and agents alike, because the signal that matters is buried under data nobody asked for. ## Instrumentation moves up the stack There is a second consequence of agents writing most of the new code, and it is a positive one. For years, the pragmatic answer to "how do we get telemetry out of this service" was to instrument at lower levels: bytecode agents, sidecars, kernel probes. These approaches produce telemetry in bulk, but they cannot know what a request means to the business, so the result skews toward high volume and low value. An agent that is writing the code anyway, and that actually knows OpenTelemetry, can do better. It can add high value, low volume instrumentation directly in the source code, at the moment the code is written: a span where a business decision happens, an attribute that captures why a request took the slow path, a metric that tracks the thing the on-call engineer will actually ask about. Lower-level instrumentation still has its place for baseline visibility, but the center of gravity shifts to purposeful instrumentation in the code itself. The catch is the qualifier: an agent that actually knows OpenTelemetry. Base models know a lot about OpenTelemetry, but their knowledge is frozen at training time, in an ecosystem that ships breaking changes, new semantic conventions, and new components every week. That gap is what we are addressing today. ## Announcing OllyGarden Agent Skills for OpenTelemetry At KubeCon® + CloudNativeCon® Europe 2026 in Amsterdam earlier this year, our colleague Nicolas Wörner, together with our friend Pavol Loffay from Red Hat, presented "Let Me Be Your OpenTelemetry Champ" and released the initial set of our [OpenTelemetry Agent Skills](https://github.com/ollygarden/opentelemetry-agent-skills). Since then, we have used these skills every day: internally, in our own engineering work, and as a foundational layer of [Rose](https://ollygarden.com/products/rose), our AI instrumentation agent, where they run alongside our more specialized skills. Today we are ready to say that this set has matured into something we recommend for any base model. In our experience, the skills improve the OpenTelemetry output of Anthropic, OpenAI, and Gemini models alike. They form what we call the "OTel Facts" layer of our knowledge fabric: facts gathered from the OpenTelemetry repositories themselves, with a strong preference for the most current source of truth there is, the source code. The skills are open source under the Apache 2.0 license, and we believe they can bring value to everyone working with OpenTelemetry, whether or not they ever use an OllyGarden product. If they lower the barrier to entry for OpenTelemetry adoption, that alone makes them worth releasing. ## What is inside The repository launched with 14 skills, and they cluster into three groups. The [current catalog](https://ollygarden.com/resources/agent-skills) lists every skill in both of our skill packages. The first group covers instrumenting services in every major ecosystem: Go, Java, Node.js, Python, .NET, and the browser. Each language skill bundles references for software development kit (SDK) setup, the instrumentation API surface, available instrumentation libraries, performance tuning, and breaking changes. The browser skill covers real user monitoring, Core Web Vitals, and connecting frontend telemetry to backend traces. The second group covers operating the telemetry pipeline: the OpenTelemetry Collector skill knows the configuration surface of individual components across the core and contrib repositories, the OpenTelemetry Transformation Language (OTTL) skill writes and debugs telemetry transformations, and the telemetrygen skill generates synthetic telemetry for testing pipelines. The third group is about staying correct over time: a skill that looks up the latest compatible SDK versions per language, a skill for semantic convention naming and compliance, a skill for OpenTelemetry Weaver, a skill for declarative configuration, which sets up the SDK through YAML instead of scattered environment variables, and a skill that migrates span events to the Logs API following the accepted OTEP 4430 plan. Those last two illustrate the whole point: declarative configuration only recently became a community recommendation, and the span events migration plan did not exist when current base models were trained. The skills bring knowledge the models could not have picked up in training. The skills follow the [agentskills.io specification](https://agentskills.io/specification) and are built around progressive disclosure: each skill's entry point is deliberately small, and the agent pulls in only the reference it needs for the task at hand. Instead of copying documentation into context, the skills use compact lookup tables and scripts that point at the upstream sources of truth. The agent retrieves what it missed during training, and the answers stay current as the OpenTelemetry project evolves. The skills are also non-opinionated by design; there are many valid ways to use OpenTelemetry, and prescribing conventions is not their job. **Add organizational context with Rose.** Rose builds on these skills, reviews the instrumentation in your GitHub repositories for missing or low-value telemetry, and prepares source-level fixes as pull requests or context for your coding agent. [Meet Rose](https://ollygarden.com/products/rose) ## Day one is easy Here is what we learned building these: shipping a set of skills on day one is the easy part. Anyone with a weekend and a scraper can do it. The hard part, and the part where the value actually lives, is everything that comes after. OpenTelemetry ships new SDK releases, renames Collector components, and evolves semantic conventions continuously. Base models get replaced, and each new model knows different things and fails in different ways. A skill set that was accurate in March quietly becomes a liability by September if nobody maintains it. That maintenance is the commitment we are making, with this repository and with our products in general. It also means tracking two moving targets, not one: the OpenTelemetry ecosystem itself, and the fast-moving practice of how agent skills are built. Techniques like progressive disclosure were not common vocabulary a year ago; we expect the state of the practice to keep changing, and we will keep adapting the skills to match it. This is also why these skills sit at the foundation of Rose. Rose layers organizational context, our specialized detection and remediation skills, and cross-service analysis on top of the OTel Facts layer. The better the foundation, the better everything built on it. ## Try them, break them, tell us about it Installing the skills takes one command: ``` npx skills add https://github.com/ollygarden/opentelemetry-agent-skills ``` Claude Code users can also add the repository as a plugin marketplace and install individual skills from there; the [README](https://github.com/ollygarden/opentelemetry-agent-skills) has the details. We built these skills with instrumentation in mind, but we keep finding new uses for them: reviewing Collector configurations, planning migrations, generating test telemetry, checking semantic convention compliance. We would love to hear where you take them, where they shined, and just as importantly, where they failed. Open an issue, and if you want to go further, contributions are welcome. Our hope is that this repository gains enough momentum that we can eventually donate it to the OpenTelemetry project, where a community-maintained knowledge layer for agents rightfully belongs. And if you want to see what these skills enable when combined with organizational context and specialized instrumentation knowledge, [try Rose](https://ollygarden.com/products/rose). It reviews the OpenTelemetry instrumentation in your pull requests and helps your team produce the high quality, high value telemetry that this new era demands.