--- updatedAt: 2026-05-20T18:57:20.000Z agentTools: projectIndex: https://docs.arthur.ai/llms.txt --- # Claude Code Skill (/arthur-onboard) Automated Arthur Instrumentation using Claude Code Skill ## Overview The `/arthur-onboard` Claude Code skill lets you instrument your application with Arthur tracing, prompts, and continuous evaluations by running a single command inside Claude Code CLI — no manual copy-pasting, no reading through multiple doc pages, no guesswork about which SDK calls to add. You type `/arthur-onboard` in your repo, and Claude walks you through the entire onboarding flow interactively, writing the instrumentation code for you. Adopting Arthur for the first time involves a sequence of steps that are easy to get wrong: standing up the engine, creating a task, adding SDK calls to your code, registering prompts, verifying that traces are flowing, configuring a model provider, and setting up continuous evaluations. The `/arthur-onboard` skill collapses all of that into one guided session. Claude reads your repository, understands your stack, and makes targeted code changes — asking for your confirmation before touching anything. > **Note:** This page covers the `/arthur-onboard` skill, which instruments *your application*. It is separate from the [Arthur Claude Code Tracer integration](https://docs.arthur.ai/docs/claude-code-tracer), which instruments Claude Code itself as an observed agent. *** ## What the Skill Does The skill is a `SKILL.md` file that Claude Code CLI loads and executes as a structured, multi-step agent workflow. When you invoke `/arthur-onboard`, Claude: * Reads the skill definition from your `~/.claude/skills/arthur-onboard/SKILL.md` (global) or `.claude/skills/arthur-onboard/SKILL.md` (project-scoped) directory * Analyzes your repository to detect your language, framework, and any existing instrumentation * Connects to your Arthur GenAI Engine instance (local Docker or remote) * Writes instrumentation code, registers prompts, and creates evaluations — all within your existing codebase The skill persists connection details (engine URL, API key, task ID) to a `.arthur-engine.env` file in your project root. This file is automatically added to `.gitignore` so credentials are never committed. ```mermaid flowchart TD A[/arthur-onboard] --> B[1. Pre-flight check] B --> C[2. Connect to Arthur Engine] C --> D[3. Create or select Task] D --> E[4. Analyze repository] E --> F[5. Instrument code] F --> G[6. Register prompts] G --> H[7. Verify traces] H --> I[8. Configure model provider] I --> J[9. Create continuous evals] J --> K[10. Done — traces & evals live] ``` *** ## Prerequisites Before running the skill, make sure you have the following: | Requirement | Details | | ------------------------ | --------------------------------------------------------------------------------------------------------- | | **Claude Code CLI** | Installed and authenticated. See the [Claude Code repository](https://github.com/anthropics/claude-code). | | **Git repository** | Recommended. The skill warns you if your repo has uncommitted changes before making any modifications. | | **Local Arthur Engine** | Docker Desktop running on macOS (if using a local install). | | **Remote Arthur Engine** | URL and API key for your deployment (if connecting to a hosted instance). | You do **not** need to pre-install any Arthur SDK — the skill detects your stack and adds the appropriate dependency for you. *** ## Quick Start (No Install) The fastest way to run the skill requires zero installation. Paste this prompt directly into Claude Code CLI: ``` Fetch https://raw.githubusercontent.com/arthur-ai/arthur-engine/refs/heads/main/integrations/claude-code-skills/arthur-onboard/SKILL.md, save it to ~/.claude/skills/arthur-onboard/SKILL.md (create the directory if it doesn't exist), read the saved file, and follow its instructions. ``` Claude fetches the latest version of the skill on the fly, saves it locally, and immediately begins the onboarding workflow. You do not need to run any install commands first. *** ## Install Globally A global install makes `/arthur-onboard` available in every project on your machine. Run this one-liner in your terminal: ```bash mkdir -p ~/.claude/skills/arthur-onboard && \ curl -sSLf https://raw.githubusercontent.com/arthur-ai/arthur-engine/main/integrations/claude-code-skills/arthur-onboard/SKILL.md \ > ~/.claude/skills/arthur-onboard/SKILL.md ``` After installation, open any repository in Claude Code CLI and run: ``` /arthur-onboard ``` **To update to the latest version**, re-run the same command — it overwrites the file in place. *** ## Install Per-Project A project-scoped install commits the skill to your repository so every team member gets it automatically when they open Claude Code in that repo. ```bash mkdir -p .claude/skills/arthur-onboard && \ curl -sSLf https://raw.githubusercontent.com/arthur-ai/arthur-engine/main/integrations/claude-code-skills/arthur-onboard/SKILL.md \ > .claude/skills/arthur-onboard/SKILL.md git add .claude/skills/arthur-onboard/SKILL.md git commit -m "Add Arthur GenAI Engine onboarding skill" ``` The skill file lives at `.claude/skills/arthur-onboard/SKILL.md` relative to your project root. Any teammate who pulls this commit can immediately run `/arthur-onboard` in Claude Code without any additional setup. **Scope comparison:** | Location | Scope | Use case | | ---------------------------------- | ------------------------------------- | ------------------------ | | `~/.claude/skills/arthur-onboard/` | Global — all projects on your machine | Personal developer setup | | `.claude/skills/arthur-onboard/` | Project — committed to the repo | Team-wide onboarding | *** ## The 10-Step Onboarding Workflow When you run `/arthur-onboard`, Claude executes the following steps in order. Claude asks for your confirmation before making any changes to your code. ### Step 1 — Pre-flight check Claude runs a `git status` check. If your working tree has uncommitted changes, the skill warns you and recommends committing or stashing before proceeding. This ensures you have a clean baseline to review the instrumentation diff. ### Step 2 — Connect to Arthur GenAI Engine Claude asks whether you are connecting to a **local Docker install** or a **remote deployment**: * **Local:** Requires Docker Desktop running on macOS. Claude verifies the engine is reachable. * **Remote:** You provide the engine URL and API key. Claude validates the connection. Connection details are saved to `.arthur-engine.env` in your project root and added to `.gitignore` automatically. ### Step 3 — Create or select an Arthur Task Claude lists existing Tasks on your engine and lets you select one, or creates a new Task for this application. The Task is the top-level container that groups all traces and evaluations for your app. ### Step 4 — Analyze your repository Claude reads your repository to determine: * Programming language (Python or TypeScript) * Framework in use (see [Supported Languages and Frameworks](#supported-languages-and-frameworks)) * Whether any Arthur or OpenTelemetry instrumentation already exists This analysis drives all subsequent code changes — Claude only adds what is missing. ### Step 5 — Instrument your code Based on the analysis, Claude adds the appropriate SDK instrumentation: * **Python apps** → `arthur-sdk` tracing calls * **Mastra TypeScript apps** → Mastra-native Arthur integration * **OpenInference / OTel apps** → OpenInference or OpenTelemetry exporter configuration Claude shows you a diff and asks for confirmation before writing any files. ### Step 6 — Extract and register prompts Claude scans your codebase for prompt strings and prompt templates, extracts them, and registers them with Arthur as named, versioned Prompts. Registered prompts unlock prompt-level analytics and evaluation targeting. ### Step 7 — Verify traces are flowing Claude triggers a test invocation of your instrumented code (or guides you to do so) and then polls the Arthur engine to confirm that traces are arriving. You see a confirmation message once the first trace is recorded. ### Step 8 — Configure a model provider for evaluations Arthur's continuous evaluations require a model provider to run LLM-as-judge scoring. Claude prompts you to configure a provider (for example, an OpenAI-compatible endpoint) and stores the credentials in `.arthur-engine.env`. ### Step 9 — Recommend and create continuous evals Based on your Task type and the prompts registered in Step 6, Claude recommends a set of continuous evaluations (for example, hallucination detection, toxicity, relevance) and creates them on the engine with your approval. ### Step 10 — Done Traces and evaluations are live. Claude summarizes what was changed, which evals are running, and where to view results in the Arthur dashboard. *** ## Supported Languages and Frameworks The skill supports the following stacks today: | Language | Framework / Integration | Notes | | ------------------------ | ------------------------------------ | -------------------------------------------------- | | **Python** | `arthur-sdk` | Direct SDK instrumentation for Python agentic apps | | **TypeScript** | Mastra | Native Arthur integration for Mastra-based agents | | **Python or TypeScript** | OpenInference / OpenTelemetry (OTel) | For apps already using OTel-compatible tracing | If your stack is not listed, the skill will still analyze your repository and may be able to apply OpenInference/OTel instrumentation as a fallback. You can also open an issue on the [arthur-engine repository](https://github.com/arthur-ai/arthur-engine) to request support for additional frameworks. *** ## Verify the Skill Worked After the skill completes, confirm that everything is working correctly: **1. Check the state file exists:** ```bash cat .arthur-engine.env ``` You should see `ARTHUR_ENGINE_URL`, `ARTHUR_API_KEY`, and `ARTHUR_TASK_ID` populated. **2. Confirm `.gitignore` was updated:** ```bash grep arthur-engine .gitignore ``` The output should include `.arthur-engine.env`. **3. Confirm instrumentation was added to your source files:** For Python projects, look for `arthur-sdk` imports and trace decorators in your agent entry points. For Mastra projects, look for the Arthur plugin configuration. For OTel projects, look for the Arthur exporter in your tracer setup. **4. Send a test request and check for traces:** Run your application and send a sample request, then open the Arthur dashboard and navigate to your Task. You should see at least one trace within a few seconds. **5. Confirm evaluations are running:** In the Arthur dashboard, navigate to **Evaluations** under your Task. The evals created in Step 9 should show a status of **Active**. *** ## Troubleshooting ### `/arthur-onboard` is not recognized as a command The skill file is not in a location Claude Code can find. Verify the file exists at one of these paths: ```bash # Global ls ~/.claude/skills/arthur-onboard/SKILL.md # Project-scoped ls .claude/skills/arthur-onboard/SKILL.md ``` If neither exists, run the [Quick Start](#quick-start-no-install) prompt or the [global install](#install-globally) command. *** ### Claude cannot connect to the Arthur Engine * **Local Docker install:** Confirm Docker Desktop is running and the Arthur engine container is up. Check with `docker ps` and look for the arthur-engine container. * **Remote deployment:** Double-check the engine URL (no trailing slash) and API key in `.arthur-engine.env`. Confirm network access from your machine to the remote host. *** ### The skill warns about uncommitted changes This is intentional. Commit or stash your current changes before running `/arthur-onboard` so you can clearly review the diff the skill produces. ```bash git stash /arthur-onboard # After the skill completes: git stash pop ``` *** ### Traces are not appearing in the dashboard * Confirm your application actually ran after instrumentation was added (Step 7 requires a live invocation). * Check that `ARTHUR_ENGINE_URL` in `.arthur-engine.env` points to the correct engine instance. * Look at your application logs for any SDK errors related to trace export. *** ### `.arthur-engine.env` was accidentally committed Remove it from tracking immediately: ```bash git rm --cached .arthur-engine.env echo ".arthur-engine.env" >> .gitignore git commit -m "Remove arthur-engine.env from tracking" ``` Rotate your API key in the Arthur engine admin panel after removing it from git history. *** ### The skill modified files I did not expect The skill asks for confirmation before writing files. If you approved a change you want to revert, use `git diff` to review and `git checkout -- ` to restore the original. *** ## Next Steps Now that your application is instrumented and evaluations are running, explore the rest of the Arthur platform: * **[Arthur GenAI Engine overview](https://docs.arthur.ai/docs/arthur-genai-engine-overview)** — Understand Tasks, traces, prompts, and evals in depth. * **[Continuous Evaluations](https://docs.arthur.ai/docs/continuous-evaluations)** — Add custom eval criteria beyond the defaults the skill created. * **[Prompt Management](https://docs.arthur.ai/docs/prompt-management)** — Version and A/B test the prompts the skill registered. * **[Arthur Dashboard](https://docs.arthur.ai/docs/dashboard-overview)** — Explore the trace explorer, eval scorecards, and alerting. * **[Python SDK reference](https://docs.arthur.ai/docs/python-sdk-reference)** — Go deeper on `arthur-sdk` instrumentation options. * **[Mastra TypeScript integration](https://docs.arthur.ai/docs/mastra-integration)** — Advanced configuration for Mastra-based agents. * **[OpenInference / OTel integration](https://docs.arthur.ai/docs/openinference-integration)** — Customize the OTel exporter the skill configured. * **[Claude Code Tracer](https://docs.arthur.ai/docs/claude-code-tracer)** — Instrument Claude Code itself as an observed agent (separate from this skill).