Agent skill

Implementing Observability

by ancoleman in ancoleman/ai-design-components

Monitoring, logging, and tracing implementation using OpenTelemetry as the unified standard.

Install Implementing Observability

skills CLI

$ npx skills add ancoleman/ai-design-components --skill implementing-observability -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI

$ gh skill install ancoleman/ai-design-components implementing-observability --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy

$ git clone --depth 1 https://github.com/ancoleman/ai-design-components.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/implementing-observability .claude/skills/implementing-observability && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Paste into Claude Code

Install the "implementing-observability" agent skill from https://github.com/ancoleman/ai-design-components/tree/main/skills/implementing-observability into .claude/skills/implementing-observability/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "implementing-observability", then confirm the skill loads.

Claude Code copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.

$skill-installer

$skill-installer install https://github.com/ancoleman/ai-design-components/tree/main/skills/implementing-observability

Type this inside Codex. $skill-installer <name> installs a curated skill from openai/skills. The installer writes to $CODEX_HOME/skills (default ~/.codex/skills). Restart Codex if the skill does not show up.

skills CLI

$ npx skills add ancoleman/ai-design-components --skill implementing-observability -a codex

Project install goes to .agents/skills/; add -g for ~/.codex/skills/.

GitHub CLI

$ gh skill install ancoleman/ai-design-components implementing-observability --agent codex

Project scope by default (.agents/skills/); add --scope user for a personal install.

Manual copy

$ git clone --depth 1 https://github.com/ancoleman/ai-design-components.git skills-src && mkdir -p .agents/skills && cp -r skills-src/skills/implementing-observability .agents/skills/implementing-observability && rm -rf skills-src

Use ~/.agents/skills/ instead of .agents/skills for a personal install.

Codex skills documentation · loads skills from .agents/skills/

Paste into Codex

Install the "implementing-observability" agent skill from https://github.com/ancoleman/ai-design-components/tree/main/skills/implementing-observability into .agents/skills/implementing-observability/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "implementing-observability", then confirm the skill loads.

Codex copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.

skills CLI

$ npx skills add ancoleman/ai-design-components --skill implementing-observability -a cursor

Project install goes to .agents/skills/; add -g for ~/.cursor/skills/.

GitHub CLI

$ gh skill install ancoleman/ai-design-components implementing-observability --agent cursor

Project scope by default (.agents/skills/); add --scope user for a personal install.

Manual copy

$ git clone --depth 1 https://github.com/ancoleman/ai-design-components.git skills-src && mkdir -p .cursor/skills && cp -r skills-src/skills/implementing-observability .cursor/skills/implementing-observability && rm -rf skills-src

Use ~/.cursor/skills/ instead of .cursor/skills for a personal install.

Cursor skills documentation · loads skills from .cursor/skills/, .agents/skills/, .claude/skills/, .codex/skills/

Paste into Cursor

Install the "implementing-observability" agent skill from https://github.com/ancoleman/ai-design-components/tree/main/skills/implementing-observability into .cursor/skills/implementing-observability/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "implementing-observability", then confirm the skill loads.

Cursor copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.

gemini skills install

$ gemini skills install https://github.com/ancoleman/ai-design-components.git --path skills/implementing-observability

--scope user (default) or --scope workspace; --path is the subfolder of the repo that holds the skill; --consent skips the security confirmation prompt.

skills CLI

$ npx skills add ancoleman/ai-design-components --skill implementing-observability -a gemini-cli

Project install goes to .agents/skills/; add -g for ~/.gemini/skills/.

GitHub CLI

$ gh skill install ancoleman/ai-design-components implementing-observability --agent gemini-cli

Project scope by default (.agents/skills/); add --scope user for a personal install.

Manual copy

$ git clone --depth 1 https://github.com/ancoleman/ai-design-components.git skills-src && mkdir -p .gemini/skills && cp -r skills-src/skills/implementing-observability .gemini/skills/implementing-observability && rm -rf skills-src

Use ~/.gemini/skills/ instead of .gemini/skills for a personal install, then run /skills reload.

Gemini CLI skills documentation · loads skills from .gemini/skills/, .agents/skills/

Paste into Gemini CLI

Install the "implementing-observability" agent skill from https://github.com/ancoleman/ai-design-components/tree/main/skills/implementing-observability into .gemini/skills/implementing-observability/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "implementing-observability", then confirm the skill loads.

Gemini CLI copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.

GitHub CLI

$ gh skill install ancoleman/ai-design-components implementing-observability

Installs for Copilot at project scope by default; add --scope user for a personal install. Preview a skill first with gh skill preview. Needs GitHub CLI 2.90.0 or later (public preview).

skills CLI

$ npx skills add ancoleman/ai-design-components --skill implementing-observability -a github-copilot

Project install goes to .agents/skills/; add -g for ~/.copilot/skills/.

Manual copy

$ git clone --depth 1 https://github.com/ancoleman/ai-design-components.git skills-src && mkdir -p .github/skills && cp -r skills-src/skills/implementing-observability .github/skills/implementing-observability && rm -rf skills-src

Use ~/.copilot/skills/ instead of .github/skills for a personal install. Commit .github/skills so cloud agent and code review can use it.

GitHub Copilot skills documentation · loads skills from .github/skills/, .claude/skills/, .agents/skills/

Paste into GitHub Copilot

Install the "implementing-observability" agent skill from https://github.com/ancoleman/ai-design-components/tree/main/skills/implementing-observability into .github/skills/implementing-observability/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "implementing-observability", then confirm the skill loads.

GitHub Copilot copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.

skills CLI

$ npx skills add ancoleman/ai-design-components --skill implementing-observability -a opencode

OpenCode documents no install command of its own. Project install goes to .agents/skills/; add -g for ~/.config/opencode/skills/.

GitHub CLI

$ gh skill install ancoleman/ai-design-components implementing-observability --agent opencode

Project scope by default (.agents/skills/); add --scope user for a personal install.

Manual copy

$ git clone --depth 1 https://github.com/ancoleman/ai-design-components.git skills-src && mkdir -p .opencode/skills && cp -r skills-src/skills/implementing-observability .opencode/skills/implementing-observability && rm -rf skills-src

Use ~/.config/opencode/skills/ instead of .opencode/skills for a personal install.

OpenCode skills documentation · loads skills from .opencode/skills/, .claude/skills/, .agents/skills/

Paste into OpenCode

Install the "implementing-observability" agent skill from https://github.com/ancoleman/ai-design-components/tree/main/skills/implementing-observability into .opencode/skills/implementing-observability/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "implementing-observability", then confirm the skill loads.

OpenCode copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.

Facts

Skill name: implementing-observability
GitHub stars: 526
Token cost: ~3k tokens
SKILL.md length: 637 words
Files: 18 (incl. scripts, references)
Skills in repo: 75
Repo updated: Dec 11, 2025
First seen: Oct 7, 2026
Licence: MIT

At a glance

Monitoring, logging, and tracing implementation using OpenTelemetry as the unified standard.

Works in 8 steps: Metrics (What is happening?) → Logs (What happened?) → Traces (Where did time go?) → …
Building production systems requiring visibility into performance
SKILL.md covers Purpose, When to Use, The OpenTelemetry Standard… and The Three Pillars of…, plus 11 more sections
Runs Python scripts from its folder; calls python, pip and docker-compose

What it does

Implementing Observability is an agent skill from ancoleman/ai-design-components. Monitoring, logging, and tracing implementation using OpenTelemetry as the unified standard. Use when building production systems requiring visibility into performance, errors, and behavior. Covers OpenTelemetry (metrics, logs, traces), Prometheus, Grafana, Loki, Jaeger, Tempo, structured logging (structlog, tracing, slog, pino), and alerting.

Its SKILL.md is about 3k tokens, which your agent loads only when the skill is triggered. The skill folder holds 23 other files, including scripts and reference files (for example `examples/axum-tracing/README.md`, `examples/fastapi-otel/README.md` and `examples/fastapi-otel/main.py`).

It sits in DevOps & Cloud, covering Observability. It works with OpenTelemetry, Prometheus, Grafana and Python. The repository describes itself as: Comprehensive UI/UX and Backend component design skills for AI-assisted development with Claude. The licence is MIT.

When your agent uses it

Building production systems requiring visibility into performance
Tasks that involve Observability

Example prompts

“/implementing-observability”

Requirements

Python 3
Docker

Workflow steps

8 steps, taken from the step headings in SKILL.md.

Metrics (What is happening?)
Logs (What happened?)
Traces (Where did time go?)
Choose Your Stack
Install OpenTelemetry SDK
Deploy LGTM Stack
Configure Structured Logging
Set Up Alerting

What it can do on your machine

Read from SKILL.md and the folder at commit 76551b7. It shows what the files ask for, not the result of running them.

Tool permissions
Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.
From allowed-tools in the SKILL.md frontmatter.
Runs code
Ships 1 file in scripts/ (Python, from the files we listed), which the agent can run.
Shell commands in SKILL.md call:
- python
- pip
- docker-compose
From the folder's file list and the shell code blocks in SKILL.md.
Network
No URLs in SKILL.md. Its commands use pip, which can reach the network depending on how they are called.
From URLs in SKILL.md, links to its own repository left out.
Credentials
Names no API keys, tokens, secrets or passwords.
From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Implementing Observability loads about 3k tokens when it runs, and up to ~25k if it reads all its reference files. Until then it costs about 93 tokens; SKILL.md has 637 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it: ~93
When it runs · the whole SKILL.md, loaded when a task matches: ~3k
With references · SKILL.md plus every file in references/, read only if the agent opens them: ~25k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); the scripts in this folder are not scanned.

SKILL.md

The full file from ancoleman/ai-design-components at commit 76551b7, republished under its MIT licence (© ancoleman). 637 words, ~3,034 tokens.

Download SKILL.mdSave it as .claude/skills/implementing-observability/SKILL.md (or your agent's skills folder). This skill also uses 17 other files; get the full folder from GitHub.

name: implementing-observability
description: Monitoring, logging, and tracing implementation using OpenTelemetry as the unified standard. Use when building production systems requiring visibility into performance, errors, and behavior. Covers OpenTelemetry (metrics, logs, traces), Prometheus, Grafana, Loki, Jaeger, Tempo, structured logging (structlog, tracing, slog, pino), and alerting.

Production Observability with OpenTelemetry

Purpose

Implement production-grade observability using OpenTelemetry as the 2025 industry standard. Covers the three pillars (metrics, logs, traces), LGTM stack deployment, and critical log-trace correlation patterns.

When to Use

Use when:

Building production systems requiring visibility into performance and errors
Debugging distributed systems with multiple services
Setting up monitoring, logging, or tracing infrastructure
Implementing structured logging with trace correlation
Configuring alerting rules for production systems

Skip if:

Building proof-of-concept without production deployment
System has < 100 requests/day (console logging may suffice)

The OpenTelemetry Standard (2025)

OpenTelemetry is the CNCF graduated project unifying observability:

┌────────────────────────────────────────────────────────┐
│          OpenTelemetry: The Unified Standard           │
├────────────────────────────────────────────────────────┤
│                                                         │
│  ONE SDK for ALL signals:                              │
│  ├── Metrics (Prometheus-compatible)                   │
│  ├── Logs (structured, correlated)                     │
│  ├── Traces (distributed, standardized)                │
│  └── Context (propagates across services)              │
│                                                         │
│  Language SDKs:                                         │
│  ├── Python: opentelemetry-api, opentelemetry-sdk      │
│  ├── Rust: opentelemetry, tracing-opentelemetry        │
│  ├── Go: go.opentelemetry.io/otel                      │
│  └── TypeScript: @opentelemetry/api                    │
│                                                         │
│  Export to ANY backend:                                │
│  ├── LGTM Stack (Loki, Grafana, Tempo, Mimir)          │
│  ├── Prometheus + Jaeger                               │
│  ├── Datadog, New Relic, Honeycomb (SaaS)              │
│  └── Custom backends via OTLP protocol                 │
│                                                         │
└────────────────────────────────────────────────────────┘

Context7 Reference: /websites/opentelemetry_io (Trust: High, Snippets: 5,888, Score: 85.9)

The Three Pillars of Observability

1. Metrics (What is happening?)

Track system health and performance over time.

Metric Types: Counters (always increase), Gauges (up/down), Histograms (distributions), Summaries (percentiles).

Brief Example (Python):

python

from opentelemetry import metrics

meter = metrics.get_meter(__name__)
http_requests = meter.create_counter("http.server.requests")
http_requests.add(1, {"method": "GET", "status": 200})

2. Logs (What happened?)

Record discrete events with context.

CRITICAL: Always inject trace_id/span_id for log-trace correlation.

Brief Example (Python + structlog):

python

import structlog
from opentelemetry import trace

logger = structlog.get_logger()
span = trace.get_current_span()
ctx = span.get_span_context()

logger.info(
    "processing_request",
    trace_id=format(ctx.trace_id, '032x'),
    span_id=format(ctx.span_id, '016x'),
    user_id=user_id
)

See: references/structured-logging.md for complete configuration.

3. Traces (Where did time go?)

Track request flow across distributed services.

Key Concepts: Trace (end-to-end journey), Span (individual operation), Parent-Child (nested operations).

Brief Example (Python + FastAPI):

python

from opentelemetry.instrumentation.fastapi import FastAPIInstrumentor

app = FastAPI()
FastAPIInstrumentor.instrument_app(app)  # Auto-traces all HTTP requests

See: references/opentelemetry-setup.md for SDK installation by language.

The LGTM Stack (Self-Hosted Observability)

LGTM = Loki (Logs) + Grafana (Visualization) + Tempo (Traces) + Mimir (Metrics)

┌────────────────────────────────────────────────────────┐
│                  LGTM Architecture                      │
├────────────────────────────────────────────────────────┤
│                                                         │
│  ┌──────────────────────────────────────────────┐      │
│  │           Grafana Dashboard (Port 3000)      │      │
│  │  Unified UI for Logs, Metrics, Traces       │      │
│  └──────┬──────────────┬─────────────┬─────────┘      │
│         │              │             │                 │
│         ▼              ▼             ▼                 │
│  ┌──────────┐   ┌──────────┐  ┌──────────┐            │
│  │   Loki   │   │  Tempo   │  │  Mimir   │            │
│  │  (Logs)  │   │ (Traces) │  │(Metrics) │            │
│  │Port 3100 │   │Port 3200 │  │Port 9009 │            │
│  └────▲─────┘   └────▲─────┘  └────▲─────┘            │
│       │              │             │                   │
│       └──────────────┴─────────────┘                   │
│                      │                                 │
│              ┌───────▼────────┐                        │
│              │ Grafana Alloy  │                        │
│              │  (Collector)   │                        │
│              │  Port 4317/8   │ ← OTLP gRPC/HTTP       │
│              └───────▲────────┘                        │
│                      │                                 │
│         OpenTelemetry Instrumented Apps                │
│                                                         │
└────────────────────────────────────────────────────────┘

Quick Start: Run examples/lgtm-docker-compose/docker-compose.yml for a complete LGTM stack.

See: references/lgtm-stack.md for production deployment guide.

Critical Pattern: Log-Trace Correlation

The Problem: Logs and traces live in separate systems. You see an error log but can't find the related trace.

The Solution: Inject trace_id and span_id into every log record.

Python (structlog)

python

import structlog
from opentelemetry import trace

logger = structlog.get_logger()
span = trace.get_current_span()
ctx = span.get_span_context()

logger.info(
    "request_processed",
    trace_id=format(ctx.trace_id, '032x'),  # 32-char hex
    span_id=format(ctx.span_id, '016x'),    # 16-char hex
    user_id=user_id
)

Rust (tracing)

rust

use tracing::{info, instrument};

#[instrument(fields(user_id = %user_id))]
async fn process_request(user_id: u64) -> Result<Response> {
    // trace_id/span_id automatically included
    info!(user_id = user_id, "processing request");
    Ok(result)
}

See: references/trace-context.md for Go and TypeScript patterns.

Query in Grafana

logql

{job="api-service"} |= "trace_id=4bf92f3577b34da6a3ce929d0e0e4736"

Quick Setup Guide

1. Choose Your Stack

Decision Tree:

Greenfield: OpenTelemetry SDK + LGTM Stack (self-hosted) or Grafana Cloud (managed)
Existing Prometheus: Add Loki (logs) + Tempo (traces)
Kubernetes: LGTM via Helm, Alloy DaemonSet
Zero-ops: Managed SaaS (Grafana Cloud, Datadog, New Relic)

2. Install OpenTelemetry SDK

Bootstrap Script:

bash

python scripts/setup_otel.py --language python --framework fastapi

Manual (Python):

bash

pip install opentelemetry-api opentelemetry-sdk \
    opentelemetry-instrumentation-fastapi \
    opentelemetry-exporter-otlp

See: references/opentelemetry-setup.md for Rust, Go, TypeScript installation.

3. Deploy LGTM Stack

Docker Compose (development):

bash

cd examples/lgtm-docker-compose
docker-compose up -d
# Grafana: http://localhost:3000 (admin/admin)
# OTLP: localhost:4317 (gRPC), localhost:4318 (HTTP)

See: references/lgtm-stack.md for production Kubernetes deployment.

4. Configure Structured Logging

See: references/structured-logging.md for complete setup (Python, Rust, Go, TypeScript).

5. Set Up Alerting

See: references/alerting-rules.md for Prometheus and Loki alert patterns.

Auto-Instrumentation

OpenTelemetry auto-instruments popular frameworks:

python

from opentelemetry.instrumentation.fastapi import FastAPIInstrumentor

app = FastAPI()
FastAPIInstrumentor.instrument_app(app)  # Auto-trace all HTTP requests

Supported: FastAPI, Flask, Django, Express, Gin, Echo, Nest.js

See: references/opentelemetry-setup.md for framework-specific setup.

Show full SKILL.md (254 more words)Show less

Common Patterns

Custom Spans

python

from opentelemetry import trace

tracer = trace.get_tracer(__name__)

with tracer.start_as_current_span("fetch_user_details") as span:
    span.set_attribute("user_id", user_id)
    user = await db.fetch_user(user_id)
    span.set_attribute("user_found", user is not None)

Error Tracking

python

from opentelemetry.trace import Status, StatusCode

with tracer.start_as_current_span("process_payment") as span:
    try:
        result = process_payment(amount, card_token)
        span.set_status(Status(StatusCode.OK))
    except PaymentError as e:
        span.set_status(Status(StatusCode.ERROR, str(e)))
        span.record_exception(e)
        raise

See: references/trace-context.md for background job tracing and context propagation.

Validation and Testing

bash

# Test log-trace correlation
# 1. Make request to your app
# 2. Copy trace_id from logs
# 3. Query in Grafana: {job="myapp"} |= "trace_id=<TRACE_ID>"

# Validate metrics
python scripts/validate_metrics.py

Integration with Other Skills

Dashboards: Embed Grafana panels, query Prometheus metrics
Feedback: Alert routing (Slack, PagerDuty), notification UI
Data-Viz: Time-series charts, trace waterfall, latency heatmaps

See: examples/fastapi-otel/ for complete integration.

Progressive Disclosure

Setup Guides:

references/opentelemetry-setup.md - SDK installation (Python, Rust, Go, TypeScript)
references/structured-logging.md - structlog, tracing, slog, pino configuration
references/lgtm-stack.md - LGTM deployment (Docker, Kubernetes)
references/trace-context.md - Log-trace correlation patterns
references/alerting-rules.md - Prometheus and Loki alert templates

Examples:

examples/fastapi-otel/ - FastAPI + OpenTelemetry + LGTM
examples/axum-tracing/ - Rust Axum + tracing + LGTM
examples/lgtm-docker-compose/ - Production-ready LGTM stack

Scripts:

scripts/setup_otel.py - Bootstrap OpenTelemetry SDK
scripts/generate_dashboards.py - Generate Grafana dashboards
scripts/validate_metrics.py - Validate metric naming

Key Principles

OpenTelemetry is THE standard - Use OTel SDK, not vendor-specific SDKs
Auto-instrumentation first - Prefer auto over manual spans
Always correlate logs and traces - Inject trace_id/span_id into every log
Use structured logging - JSON format, consistent field names
LGTM stack for self-hosting - Production-ready open-source stack

Common Pitfalls

Don't:

Use vendor-specific SDKs (use OpenTelemetry)
Log without trace_id/span_id context
Manually instrument what auto-instrumentation covers
Mix logging libraries (pick one: structlog, tracing, slog, pino)

Do:

Start with auto-instrumentation
Add manual spans only for business-critical operations
Use semantic conventions for span attributes
Export to OTLP (gRPC preferred over HTTP)
Test locally with LGTM docker-compose before production

Success Metrics

100% of logs include trace_id when in request context
Mean time to resolution (MTTR) decreases by >50%
Developers use Grafana as first debugging tool
80%+ of telemetry from auto-instrumentation
Alert noise < 5% false positives

Files

SKILL.md and 17 other files (scripts, references) in skills/implementing-observability of ancoleman/ai-design-components.

SKILL.md
examples/axum-tracing/README.md
examples/fastapi-otel/README.md
examples/fastapi-otel/main.py
examples/fastapi-otel/requirements.txt
examples/grafana-dashboards/api-overview.json
examples/lgtm-docker-compose/README.md
examples/lgtm-docker-compose/docker-compose.yml
outputs.yaml
references/alerting-rules.md
references/lgtm-stack.md
references/opentelemetry-setup.md
references/structured-logging.md
references/trace-context.md
scripts
… and 3 more

Open the folder on GitHubat commit 76551b7

Compare with similar skills

Implementing Observability next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Implementing Observability compared with similar skills
Skill	Stars	Used in	Tokens	Auto-check	Licence	Repo updated
Implementing Observability this skillancoleman/ai-design-components	526	—	~3k	Automated safety check: Pass	MIT	10 mo ago
Archestra Dev Observabilityarchestra-ai/archestra	4.3k	—	~1.2k	Automated safety check: Pass	Custom licence	today
Frontmcp Observabilityagentfront/frontmcp	146	—	~4.6k	Automated safety check: Pass	Apache-2.0	today
Monitoring Observabilityahmedasmar/devops-claude-skills	203	—	~3.9k	Automated safety check: Pass	None	5 mo ago
Monitoring ExpertJeffallan/claude-skills	12k	—	~1.6k	Automated safety check: Pass	MIT	4 days ago
Alloygrafana/skills	278	—	~1.3k	Automated safety check: Pass	Apache-2.0	today

Similar skills

Archestra Dev Observability
archestra-ai/archestra
A skill your agent uses when changing Archestra tracing, metrics, OpenTelemetry, Tempo, Grafana, Prometheus, LLM/MCP spans, observability labels, or local observability setup.
4.3k GitHub stars~1.2k tokensUpdated today
DevOps & CloudAuto-check passed
Frontmcp Observability
agentfront/frontmcp
A skill your agent uses when adding tracing, structured logging, metrics, or monitoring to a FrontMCP server.
146 GitHub stars~4.6k tokensUpdated today
DevOps & CloudAuto-check passed
Monitoring Observability
ahmedasmar/devops-claude-skills
Monitoring and observability strategy, implementation, and troubleshooting.
203 GitHub stars~3.9k tokensUpdated 5 mo ago
DevOps & CloudAuto-check passed
Monitoring Expert
Jeffallan/claude-skills
Sets up application monitoring: structured logs, Prometheus metrics, OpenTelemetry tracing, Grafana dashboards, alert rules and load tests with k6 or Artillery.
12k GitHub stars~1.6k tokensUpdated 4 days ago
DevOps & CloudAuto-check passed
Alloy
grafana/skills
Official
Build a unified telemetry pipeline with Grafana Alloy — one OpenTelemetry-compatible binary that collects metrics, logs, traces, and profiles and ships to Grafana Cloud / Prometheus / Loki / Tempo /…
278 GitHub stars~1.3k tokensUpdated today
DevOps & CloudAuto-check passed
Golang Observability
context-labs/whip
Go observability — always-on production signals: slog logging, Prometheus metrics, OpenTelemetry tracing, pprof profiling, alerting, Grafana.
1.1k GitHub starsUsed in 1 repo~3.3k tokens
DevOps & CloudAuto-check passed

Questions about Implementing Observability

What does Implementing Observability do?

Monitoring, logging, and tracing implementation using OpenTelemetry as the unified standard. Implementing Observability is an agent skill from ancoleman/ai-design-components. Monitoring, logging, and tracing implementation using OpenTelemetry as the unified standard.

When should I use Implementing Observability?

Implementing Observability fits situations like: building production systems requiring visibility into performance; tasks that involve Observability.

How do I install Implementing Observability in Claude Code?

Run `npx skills add ancoleman/ai-design-components --skill implementing-observability -a claude-code`. Or copy the skill folder (skills/implementing-observability in ancoleman/ai-design-components) into .claude/skills/implementing-observability in your project. Claude Code loads it when a task matches its description.

How do I install Implementing Observability in Codex?

Run `npx skills add ancoleman/ai-design-components --skill implementing-observability -a codex`. Or copy the skill folder (skills/implementing-observability in ancoleman/ai-design-components) into .agents/skills/implementing-observability in your project. Codex loads it when a task matches its description.

Can I use Implementing Observability in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add ancoleman/ai-design-components --skill implementing-observability -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/implementing-observability, .gemini/skills/implementing-observability, .github/skills/implementing-observability and .opencode/skills/implementing-observability in your project.

What does Implementing Observability need to run?

Going by SKILL.md and its folder, Implementing Observability needs Python for the scripts in its folder and the command-line tools its instructions call (python, pip and docker-compose). Our summary lists: Python 3; Docker.

Does Implementing Observability access the network?

SKILL.md contains no URLs. Its commands use pip, which can reach the network depending on how they are called. This is read from the text; nothing was executed.

Is Implementing Observability safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. The check reads SKILL.md only: the scripts in the folder are not scanned, so read them before running anything.

What licence does Implementing Observability use?

Implementing Observability is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Implementing Observability use?

About 3k tokens (SKILL.md is roughly 12k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 22k tokens, read only when the agent opens those files.

What are the alternatives to Implementing Observability?

Skills that share tags, products or a category with Implementing Observability: Archestra Dev Observability (archestra-ai/archestra, 4.3k stars), Frontmcp Observability (agentfront/frontmcp, 146 stars), Monitoring Observability (ahmedasmar/devops-claude-skills, 203 stars) and Monitoring Expert (Jeffallan/claude-skills, 12k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Implementing Observability?

ancoleman (a GitHub user) maintains it in ancoleman/ai-design-components, which has 526 GitHub stars. The repository holds 75 skills in this directory. The repository was last updated on December 11, 2025.

Source: ancoleman/ai-design-components on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.

Install Implementing Observability

Facts

At a glance

What it does

When your agent uses it

Example prompts

Requirements

Workflow steps

What it can do on your machine

Tool permissions

Runs code

Network

Credentials

Context cost

Safety

SKILL.md

Production Observability with OpenTelemetry

Purpose

When to Use

The OpenTelemetry Standard (2025)

The Three Pillars of Observability

1. Metrics (What is happening?)

2. Logs (What happened?)

3. Traces (Where did time go?)

The LGTM Stack (Self-Hosted Observability)

Critical Pattern: Log-Trace Correlation

Python (structlog)

Rust (tracing)

Query in Grafana

Quick Setup Guide

1. Choose Your Stack

2. Install OpenTelemetry SDK

3. Deploy LGTM Stack

4. Configure Structured Logging

5. Set Up Alerting

Auto-Instrumentation

Common Patterns

Custom Spans

Error Tracking

Validation and Testing

Integration with Other Skills

Progressive Disclosure

Key Principles

Common Pitfalls

Success Metrics

Files

Compare with similar skills

Similar skills

More from ancoleman/ai-design-components

Related

Questions about Implementing Observability