Claude API skill (first-party, open source)

Why you'd careThe problem it solves

Ask any model to write Anthropic SDK code and you get something fluent and subtly wrong: a model ID with a date suffix that no longer exists, thinking: {"type": "enabled", "budget_tokens": 8000} on a model that returns 400 for it, a temperature parameter that was removed, an invented beta header. The code looks right. It fails at runtime, and the error message rarely points at the real cause. This happens because the API changed faster than any training cutoff, and it happens to every model including Anthropic's own. The claude-api skill is the correction layer: a bundle of dated reference material that loads when a task looks Anthropic-shaped, so the model writes from documentation instead of memory. It is also the clearest counterexample to the assumption that "skill" means "document generator in a sandbox".

ConceptWhat it is

The Claude API skill is a first-party, open-source skill published in the anthropics/skills repository and bundled with Claude Code. It covers Anthropic API reference material, SDK documentation and best practices — model IDs and pricing, thinking and effort parameters, prompt caching, tool use, Managed Agents, error codes, migration guidance — organised so that only the relevant slice loads.

Structurally it is the plain, unglamorous form of a skill: a SKILL.md whose body is instructions and trigger rules, plus a tree of supporting Markdown the instructions tell the model when to read. Nothing executes. There is no container, no code-execution tool, no container.skills entry and no file ID at the end. That is the boundary against the document skills, and it is a sharp one: pptx, xlsx, docx and pdf are hosted skills selected per API request that exist to run scripts; claude-api is a local skill discovered on disk that exists to supply knowledge.

Its other near neighbour is a system prompt, and the difference is cost. Everything in this bundle could be pasted into a system prompt — and would then be paid for on every request, including the ones about CSS. Progressive disclosure is what makes a reference library of this size affordable: the description sits in context, the body loads on a match, the deep reference files load only when the task reaches them.

How it worksThe mechanics

The trigger rules are unusually explicit for a skill, because the failure being prevented is silent. The skill instructs the model to load it before opening the target file whenever the prompt names Claude or Anthropic in any form — the product names, an @anthropic-ai package, a claude-* model string — whenever the user asks about an LLM's pricing, limits or model choice, and whenever the task is LLM-shaped with the provider unstated. It also specifies when to skip: if another vendor is named or a grep finds another provider's SDK in the project, the skill stands down rather than producing Anthropic code in an OpenAI file.

The reference tree, inspected on a Claude Code 2.1.220 install on 2026-07-25, looks like this:

claude-api/
  shared/       25 cross-language files:
                models.md  platform-availability.md  prompt-caching.md
                model-migration.md  tool-use-concepts.md  error-codes.md
                managed-agents-*.md  live-sources.md  ...
  python/       claude-api/{README,batches,files-api,streaming,tool-use}.md
                managed-agents/README.md
  typescript/  go/  java/  ruby/  csharp/  php/  curl/

A note on a detail worth getting right: the skill is often summarised as covering "eight programming languages". There are eight language directories, but one of them is curl — raw HTTP, not a language. The accurate statement is seven official SDK languages plus a raw-HTTP path.

Two design choices carry most of the value. Reference files are dated and say so, so a stale row is visible rather than silently authoritative. And live-sources.md lists the canonical documentation URLs with per-topic extraction prompts, so when the cached answer is not good enough the model fetches rather than guesses.

At a glanceSee it

The skill intercepts a stale training prior and routes the model through dated reference files instead.

Where it runsSurfaces and availability

This table used to be mostly Unverified; most of those rows now resolve to a specific No, and the reason is a single documented fact: Anthropic's hosted skill_id namespace contains exactly four entries — pptx, xlsx, docx, pdf — and this skill is not one of them on any surface. What it is instead is bundled (Claude Code) or installable (anywhere that accepts a SKILL.md folder or a Skills API upload). Because the source is open, the No rows are cheap to route around: register the published directory as a custom Skill, install it from the skills repository, or paste the relevant reference file into your own context. One row is still genuinely open — the Agent SDK loads Skills from the filesystem, and whether Claude Code's bundled set travels with the library is documented neither way. Checked against primary sources 2026-07-25.

ExampleIn the real world

An engineer opens a repository and types: "add streaming to the summarizer and give it a thinking budget of 10k tokens." Both halves of that request are traps. The phrase "thinking budget" points at budget_tokens, which is removed on current Opus and Sonnet models and returns a 400; and the model's prior probably still contains a date-suffixed model ID from an older release.

The trigger fires on "summarizer" plus the anthropic import in the project. The skill loads, detects Python from pyproject.toml, and reads the Python reference plus the shared models and migration tables. Instead of writing what was asked for, the assistant writes thinking={"type": "adaptive"} with an output_config effort level, uses a bare model alias with no date suffix, and switches the call to client.messages.stream(...) with get_final_message() because the output cap is high enough to risk an HTTP timeout otherwise.

Crucially it also says why, in one line: the fixed thinking-budget parameter was replaced by adaptive thinking and effort, and sending it now errors. The engineer gets working code plus the one sentence that stops them asking for the same wrong thing next week — which is the actual product of a reference skill, more than the diff is.

Not thisWhat it is often confused with

• Not a hosted skillthere is no {"type": "anthropic", "skill_id": ...} entry to add to container.skills for this. It is a folder discovered on the filesystem, which is a different loading mechanism entirely.
• Not RAGno embeddings, no vector store, no similarity search. Routing is by written instruction: the SKILL.md names which file to open for which task, and the model follows it.
• Not a system prompta system prompt is paid for on every request. This bundle loads only when the trigger matches, and its deep reference files only when the task reaches them.
• Not a tool or an MCP servernothing executes and nothing is called. It supplies text the model reads; there is no schema and no process on the other end.
• Not a substitute for the live docsthe bundle is a dated cache. It ships a list of canonical URLs precisely because it expects to go stale between releases.

LimitsWhen not to reach for it

• The project targets another provider.The skill's own instructions say to stand down when an OpenAI, Gemini, Mistral or Ollama SDK is present. Loading it anyway invites Anthropic-shaped code in a file that cannot use it.
• The question is about your product, not the API.Business logic, pricing strategy and architecture decisions are not in the bundle. It will not stop you from asking, and it will not help.
• You need a guarantee of currency.For anything where being wrong is expensive — a quoted price, a contract term, a compliance claim — fetch the live documentation rather than trusting a cached table.
• You are running on Bedrock or Vertex.There is no skills mechanism to load it. Vendor the reference files into your own prompt assembly instead.
• You want executable behaviour.This skill supplies knowledge. If you need something built or run, that is a tool, a script or the code-execution container — a reference bundle will not do it for you.

RelatedGo deeper