How to use the Arize AX Tracing Setup agent skill

What an agent skill is and what this one does

An agent skill is a folder of instructions (a SKILL.md file plus optional reference files) that an AI coding agent loads when a request matches the skill's description. This skill covers adding Arize AX tracing to an application for the first time.

The skill follows a two-phase flow. In the first phase the agent reads your codebase without changing anything, then summarizes the language, LLM providers and frameworks it found. In the second phase, after you confirm, it adds tracing code. It prefers the framework's built-in integration and reads credentials from environment variables instead of hardcoding API keys.

• Read-only analysis first: the skill says not to write code or create files during analysis.
• Business logic is left alone: the skill describes tracing as purely additive.
• Auto-instrumentation is preferred; manual spans are added for custom logic that integrations do not cover.
• Secrets are referenced through environment variables such as ARIZE_API_KEY, never written as literal values.

Install the arize-instrumentation skill

Download the ZIP for the skill from the awesome-copilot page on this site. Unzip it into your personal skills folder, ~/.claude/skills/, so it is available in every project. To limit it to one project, unzip it into that project's .claude/skills/ folder instead.

If you use the Claude apps, you can instead upload the skill under Settings → Capabilities → Skills.

• Personal install: unzip into ~/.claude/skills/
• Project install: unzip into the project's .claude/skills/ folder
• Claude apps: Settings → Capabilities → Skills, then upload

Before you start: what you need

The skill needs an Arize AX account with an API key, which you set as an environment variable such as ARIZE_API_KEY. You also need your Arize space ID and a project name. You supply these yourself; the agent should not invent them.

Your project also needs a working language package manager: pip, poetry or uv for Python; npm, pnpm or yarn for TypeScript/JavaScript; maven or gradle for Java; or go modules for Go. The ax CLI is only needed if post-change verification requires it.

• Arize AX account and API key (for example ARIZE_API_KEY)
• Arize space ID and project name
• Package manager for your language
• ax CLI, only if verification needs it

Trigger the skill with a natural request

Ask the agent in plain language. Requests such as 'instrument my app with Arize', 'add tracing from scratch' or 'set up LLM observability' match the skill's description. The skill's own quick start suggests this wording when you want the agent to follow the official setup prompt and ask questions as needed.

If your repository has several services, say which one you mean. The skill asks which service to instrument before editing anything in a monorepo.

• 'Instrument my app with Arize AX.'
• 'Add tracing from scratch to this LLM app.'
• 'Follow the instructions from https://arize.com/docs/PROMPT.md and ask me questions as needed.'
• 'Set up OpenTelemetry tracing for the billing service only.'

Review the analysis and confirm

Once the agent finishes analysis, expect a concise summary: the detected language, package manager, LLM providers and frameworks, a proposed integration list, any existing OpenTelemetry or tracing setup, and, for monorepos, which services it proposes to instrument.

If your app uses LLM tool use or function calling, the summary will also say that manual CHAIN and TOOL spans will be added so each tool call appears in the trace with its input and output. Check this list before confirming. If the summary is wrong, correct it now, before any code is changed.

Understand what changes in your code

Tracing code is added after you confirm. The skill checks for existing tracing first, looking for TracerProvider, register(), opentelemetry imports, ARIZE_, OTEL_ and OTLP_ environment variables, and other observability setup such as Datadog or Honeycomb. Even so, the skill may still add code to an app that already has tracing, so review changes in a version-controlled project.

Where a framework has its own Arize integration, the skill prefers that path. Separate provider instrumentation is added only when the framework docs require it or the framework leaves obvious gaps.

• Python and TypeScript/JavaScript use openinference-instrumentation packages for auto-instrumentation.
• Java and Go use the OpenTelemetry SDK with manual OpenInference spans.
• The skill asks you not to generate extra documentation or summary files.

Safety notes: scripts and network access

This skill runs scripts and uses the network. The instructions point to arize.com documentation, which the agent may fetch while it works, and the ax CLI may be run for verification. Read the SKILL.md file and references/ax-profiles.md before installing if you need to know exactly what runs.

The skill says never to pass a raw API key as a flag. If authentication fails, the agent consults references/ax-profiles.md, which tells it to inspect profiles with ax profiles show and to reference ARIZE_API_KEY from the environment. The skill also says the agent must never output raw secret values, including space IDs.

• Keep API keys in environment variables, not in source files.
• Review the diff after the agent makes changes.
• The skill says it will not silently replace a space ID, project name or project ID; mismatches are reported as blockers.