> ## Documentation Index
> Fetch the complete documentation index at: https://docs.decimal.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Tutorials

> Five tutorials, what each one actually costs you, and what you are holding at the end — starting with the one that needs no account at all.

Five tutorials. They are not a sequence and you are not meant to do all of them — each answers a different question, and the wrong pick costs you a signup you didn't need. Pick by what you want to be **holding** at the end.

## Start here: the part that needs nothing

The registry's read path is open. No account, no API key, no card, no trial clock:

```bash theme={null}
pip install decimalai
decimalai skills pull playwright-cli --out .claude/skills/
```

```
  ✓ Pulled playwright-cli v2
    → .claude/skills/playwright-cli/SKILL.md
    SkillScore 100 (provisional) · +79 pts vs no skill
    → 19 bundled file(s) (scripts/references/…)
    → .claude/skills/playwright-cli/eval.yaml (24 test cases)

  Efficiency vs no skill: +126% tokens · +0% turns
```

That is **2.9 seconds to install and 4.0 seconds to pull** — 8.1 seconds from an empty directory, counting the virtualenv. What lands on disk is a `SKILL.md` your runtime auto-discovers *plus* the 24-case `eval.yaml` that produced the +79-point number, so you can [re-run the benchmark yourself](/guides/skillevaluation#run-it-locally-free) instead of believing it. Note that the CLI prints the price alongside the lift: this skill buys those points with 126% more tokens, because it puts a command reference in the prompt. Lift is never free, and the registry shows you both halves.

(`playwright-cli` is just the example the first tutorial uses. Swap in any slug from the [registry](https://app.decimal.ai/skills) — the command is the same and so is the cost: nothing.)

Don't want Python either? The same skill is a `curl` away, an MCP tool call, or — inside Claude Code — one `/decimalai:install playwright-cli` with nothing to `pip install`. See [Use skills without the SDK](/guides/use-skills-without-the-sdk).

## Pick one

| Tutorial                                                              | What you need                                          | Time to the artifact                   | What you end up holding                                                 |
| --------------------------------------------------------------------- | ------------------------------------------------------ | -------------------------------------- | ----------------------------------------------------------------------- |
| [**Install a Skill**](/tutorials/install-a-skill)                     | Python. **No account.**                                | \~1 min, and 8s of that is the install | a measured `SKILL.md` and its 24-case eval suite, on disk               |
| [**The 2-Minute Demo**](/tutorials/two-minute-demo)                   | Python + an API key (Free plan)                        | \~1 min, one command each              | a rendered impact report over 120 seeded traces                         |
| [**Support Agent from Skills**](/tutorials/support-agent-from-skills) | account, SDK + a framework extra, a model provider key | not measured — the longest of the five | an agent assembled from measured skills, wired so usage actually counts |
| [**Skills Observability**](/tutorials/skills-observability)           | an agent already instrumented and sending traces       | **days, not minutes** — see below      | per-skill activation and effectiveness on *your own* traffic            |
| [**Training Pipeline**](/tutorials/training-pipeline)                 | seven things — see below                               | as long as your fine-tune job takes    | a filtered SFT dataset, and a fine-tuned model if you launch one        |

<Note>
  **The two that are further away than they look.**

  **Skills Observability** has no setup cost and a long wait: its payoff steps read analytics that only exist once *your* traffic has accumulated. The page's own worked example is labelled "after 1 week" — treat it as the thing you read once traces are already flowing, not a thing you can do this afternoon.

  **Training Pipeline** lists four prerequisite bullets that unpack to seven: Python, the SDK, the `evals` extra, the `langchain` extra, a `DECIMAL_API_KEY`, an agent already producing traces, and an OpenAI or Together.AI key for the fine-tune itself. It is the deepest tutorial here and it assumes everything the others teach.
</Note>

## What actually needs an account

<CardGroup cols={3}>
  <Card title="Nothing at all" icon="lock-open">
    Read any scorecard, pull any skill with its eval suite, re-run that benchmark locally on your own model key. Anonymous the whole way.
  </Card>

  <Card title="A free API key" icon="key">
    Seeded demos, tracing your own agent, per-skill analytics. Signup shows you a key once; [Free is generous on purpose](/pricing).
  </Card>

  <Card title="Account + provider key" icon="server">
    Anything that runs a model on your behalf — forking skills into your workspace, end-to-end agent tutorials, fine-tuning.
  </Card>
</CardGroup>

## The five

<CardGroup cols={2}>
  <Card title="Install a Skill" icon="wand-magic-sparkles" href="/tutorials/install-a-skill">
    You use Claude Code or Cursor. Read one skill's verified benchmark — the lift, the model, the token cost, the safety band — then put it on disk and watch it fire. No account.
  </Card>

  <Card title="The 2-Minute Demo" icon="play" href="/tutorials/two-minute-demo">
    One command seeds a demo agent with two manifest versions and a trace corpus, then shows you the impact report. Another does the same for the ranked registry. No agent code, no LLM keys.
  </Card>

  <Card title="Build a Support Agent from Skills" icon="headset" href="/tutorials/support-agent-from-skills">
    Replace a 900-line mega-prompt with a lean prompt plus a routed skill bundle — every skill's evidence read off its live scorecard, including the one that gets dropped for failing to earn its place.
  </Card>

  <Card title="Skills Observability" icon="chart-line" href="/tutorials/skills-observability">
    Which of your skills are actually being used, which version wins, and which one to retire. Read this once your own traces are flowing.
  </Card>

  <Card title="End-to-End Training Pipeline" icon="graduation-cap" href="/tutorials/training-pipeline">
    Trace → evaluate → build a filtered dataset → fine-tune → deploy → new traces. The flywheel, with the staleness filtering that keeps a bad trace out of your training set.
  </Card>
</CardGroup>

## Not sure any of these is the question you have

<CardGroup cols={2}>
  <Card title="Introduction" icon="book-open" href="/introduction">
    What the product is and the one idea underneath it, in prose.
  </Card>

  <Card title="Quickstart" icon="bolt" href="/quickstart">
    The reference setup path rather than a worked example — install, init, first trace.
  </Card>
</CardGroup>

<Note>
  **Where these numbers come from.** The install and pull timings were measured on 2026-08-17 in a fresh virtualenv with `DECIMAL_API_KEY` unset, against `decimalai` 0.10.3 from PyPI. The lift and case count are pinned to the live scorecard in this page's frontmatter, so a re-benchmark breaks the build rather than leaving a stale number here. The prerequisite counts are read off each tutorial's own page. Times you see on your own machine will vary with your network — the point of the numbers is the *order of magnitude*, and which side of the account wall each tutorial sits on.
</Note>