quality-observability-performance

Implement OpenTelemetry observability and SLOs for production AI agent systems.

73|16|Updated Nov 14, 2025
One-click install
npx skills add https://github.com/vasilyu1983/AI-Agents-public --skill quality-observability-performance
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: quality-observability-performance
Source: https://github.com/vasilyu1983/AI-Agents-public/tree/main/frameworks/claude-code-kit/initial-setup/skills/quality-observability-performance
Command: npx skills add https://github.com/vasilyu1983/AI-Agents-public --skill quality-observability-performance

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) and assets (resource) components.

What problem does it solve?

Debugging and optimizing complex cloud-native systems is challenging without proper visibility into their behavior and performance. This Skill provides execution-ready patterns for building observable and performant systems.

Core Features & Use Cases

  • Unified Observability: Implement OpenTelemetry for distributed tracing, Prometheus for metrics, and structured logging for comprehensive system visibility.
  • SLO-Driven Reliability: Define Service Level Objectives (SLOs) and Service Level Indicators (SLIs) to drive alerting, manage error budgets, and ensure system reliability.
  • Performance Engineering: Conduct CPU/memory profiling, capacity planning, load testing, and frontend performance optimization to proactively identify and resolve bottlenecks.

Quick Start

Use the quality-observability-performance skill to set up OpenTelemetry instrumentation for my Node.js microservice and define SLOs for its API endpoints.

Frequently Asked Questions about quality-observability-performance

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I set up OpenTelemetry instrumentation for distributed tracing in my microservice?

OpenTelemetry provides a vendor-neutral framework for collecting traces, metrics, and logs across distributed systems. Instrument your services by adding OpenTelemetry SDKs, configuring exporters to send telemetry to backends like Prometheus or Jaeger, and adding trace spans around critical operations to track requests end-to-end.

What's the difference between SLOs, SLIs, and error budgets in production systems?

Service Level Objectives (SLOs) define target reliability commitments; Service Level Indicators (SLIs) measure actual performance against those targets. Error budgets quantify how much unreliability you can tolerate within your SLO window, enabling data-driven decisions on feature development versus stability work.

How do I identify and fix performance bottlenecks in a cloud-native system?

Performance engineering combines CPU and memory profiling, load testing, and capacity planning to locate bottlenecks before they reach production. Collect baseline metrics, simulate realistic traffic patterns, analyze resource utilization hotspots, and validate improvements iteratively.

Can I use structured logging with OpenTelemetry for unified observability?

Yes. Structured logging pairs with OpenTelemetry traces and Prometheus metrics to create unified observability. Output logs as JSON with consistent fields, correlate them to trace IDs, and route all signals to centralized analysis platforms for complete system visibility.

Do I need a monitoring backend like Prometheus before implementing observability patterns?

A monitoring backend is essential for collecting and storing metrics and traces at scale. Prometheus collects metrics; tracing systems like Jaeger store distributed traces. Both integrate with OpenTelemetry exporters to enable production-grade observability and alerting on SLIs.

What's the best approach to optimize frontend performance in a distributed system?

Frontend performance optimization includes measuring Core Web Vitals, profiling JavaScript execution, reducing bundle size, and caching strategies. Pair these with backend observability to correlate frontend delays with service latency, enabling end-to-end performance tuning.