Claude Code Skill (/arthur-onboard)

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, 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.

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:

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:

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.

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:

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)
• 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:

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 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:

cat .arthur-engine.env

You should see ARTHUR_ENGINE_URL, ARTHUR_API_KEY, and ARTHUR_TASK_ID populated.

2. Confirm .gitignore was updated:

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:

# Global
ls ~/.claude/skills/arthur-onboard/SKILL.md

# Project-scoped
ls .claude/skills/arthur-onboard/SKILL.md

If neither exists, run the Quick Start prompt or the global install 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.

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:

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 -- <file> 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 — Understand Tasks, traces, prompts, and evals in depth.
• Continuous Evaluations — Add custom eval criteria beyond the defaults the skill created.
• Prompt Management — Version and A/B test the prompts the skill registered.
• Arthur Dashboard — Explore the trace explorer, eval scorecards, and alerting.
• Python SDK reference — Go deeper on arthur-sdk instrumentation options.
• Mastra TypeScript integration — Advanced configuration for Mastra-based agents.
• OpenInference / OTel integration — Customize the OTel exporter the skill configured.
• Claude Code Tracer — Instrument Claude Code itself as an observed agent (separate from this skill).