31 skills · category

AI Engineering skills for Claude Code

Skills for shipping AI features rather than demos: LLM API integration, production prompts, RAG and vector search, evals, structured outputs, tool-using agents, multi-agent orchestration, prompt caching and cost control, fine-tuning, local models, and prompt-injection defense.

Download all 31 (.zip) Browse the list

Every ai engineering skill

Each card opens the full playbook, example prompts and install commands.

No. 237

Agent Memory

Remember what matters, forget on request

Claude designs agent memory from recall tests outward: which layers you actually need, a schema with provenance and expiry, a write policy that refuses secrets and untrusted content, conflict handling when facts change, and deletion that purges vectors and summaries too. It red-teams memory poisoning and cross-user leakage before anything ships.

agent-memory 190 lines

★ No. 238

Computer-Use Agents

Agents that click safely, inside a sandbox

Claude builds browser and desktop agents the way an operator would want them: in a throwaway VM with an egress allowlist, with a code-level gate that pauses for human approval before payments, sends, deletes, or account changes, and with on-screen text treated as untrusted. It picks API or Playwright over pixels when it can and measures success rate on a fixed scenario suite.

computer-use-agents 223 lines

No. 239

Computer Vision

Detectors that hold up on your real cameras

Claude approaches vision work data-first. It picks the simplest task type that answers the question, writes labeling guidelines, splits by camera or video so frames cannot leak, validates YOLO datasets with a bundled checker, trains from pretrained weights, chooses per-class thresholds from precision-recall targets, and verifies exported ONNX or TensorRT models still match on the target hardware.

computer-vision 185 lines · 2 files

No. 240

Content Moderation

Policy first, thresholds from data, humans for the gray zone

Claude starts moderation work from a written policy with near-miss examples, not from a toxicity score. It builds a labeled evaluation set, layers normalization, blocklists, a moderation API, an LLM judge and a human queue, sets thresholds per category from precision and recall targets, and adds appeals, statements of reason and an audit log that records the policy version behind each decision.

content-moderation 224 lines · 2 files

No. 241

Document Extraction with LLMs

Invoices to validated JSON, with evidence per field

Claude turns invoices, receipts, and contracts into structured records you can trust. It designs nullable schemas with verbatim evidence for key fields, extracts with schema-constrained output from native PDFs or scans, checks totals, dates, and IDs in code, and routes anything doubtful to human review. A bundled scorer reports per-field accuracy, misses, and hallucinations against a gold set.

document-extraction-llm 237 lines · 2 files

No. 242

Fine-Tuning

Fine-tune only after the prompt baseline plateaus

Claude starts by asking whether fine-tuning is the right tool, measuring the best prompt and retrieval setup first. When tuning is warranted it builds deduplicated, consistently labeled chat datasets with leak-free splits, trains LoRA or QLoRA with TRL using conservative defaults and val-loss checkpointing, and compares the result to the prompted baseline through the real serving stack.

fine-tuning 180 lines

No. 243

Hugging Face Transformers

Pinned models, right templates, correct padding

Claude uses the Hugging Face stack without the classic silent bugs. It pins model revisions, loads safetensors in an explicit dtype and device map, formats prompts with the model's own chat template, pads left for batched generation and decodes only new tokens. Datasets are mapped in batches, classifiers trained with Trainer, and every pipeline is checked against known-good outputs.

huggingface-transformers 230 lines

No. 244

Image Generation

Consistent image sets, priced per accepted image

Claude builds image pipelines that produce usable sets rather than lucky samples. It picks a hosted API or open diffusion model by task and license, writes structured prompt templates, locks consistency with seeds, references, or LoRAs, uses a vision LLM as a calibrated critic, moderates prompts and outputs, composites real logos and text afterward, and tracks cost per accepted image.

image-generation 199 lines

No. 245

LLM App Builder

Ship LLM features with timeouts, streams, and budgets

Claude builds LLM features the way a production team would: one client module with timeouts and typed retries, streaming for anything a user waits on, a model picked by a small eval instead of reputation, and per-request cost logged from the first deploy. Every stop reason, including truncation and refusal, gets explicit handling and a test.

llm-app-builder 225 lines

★ No. 246

LLM Batch Jobs

Every input accounted for, at batch prices

Claude runs bulk LLM work so nothing is lost or double-written. It pilots the prompt first, builds a manifest with deterministic custom IDs, estimates cost before submitting, chunks work into batches, saves raw results, and sorts failures into retryable and needs-a-human. A bundled script reconciles the manifest against every results file and writes the retry list automatically.

llm-batch-jobs 208 lines · 2 files

No. 247

LLM Classification

Labels that match careful humans, per class

Claude builds classifiers starting from the taxonomy, not the prompt. It writes label definitions with boundary examples and an escape label, measures human agreement with Cohen's kappa, constrains outputs to an enum, and reports per-class precision and recall on a frozen test set. Uncertain items escalate through a model cascade or to humans, and a bundled script computes kappa, confusion matrices, and macro-F1.

llm-classification 195 lines · 2 files

★ No. 248

LLM Evals

Know whether the change helped, with error bars

Claude builds evals that can actually decide things. Cases come from real traffic and past failures, each criterion gets the cheapest reliable grader, and any LLM judge is checked against human labels before its scores count. Version comparisons are paired on the same cases with a McNemar test and bootstrap interval, and a bundled script fails CI when must-pass cases regress.

llm-evals 173 lines · 2 files

No. 249

LLM Gateway Routing

Fallbacks that are tested, retries that cannot snowball

Claude treats multi-provider routing as a contract per route rather than a list of model names. It builds an error-to-action table, splits time-to-first-token from total deadlines, caps retries with a budget, checks that each fallback passes the route's eval, and picks between an in-app router, a LiteLLM proxy, or a managed gateway, including when you need none of them.

llm-gateway-routing 263 lines · 2 files

No. 250

LLM Observability

Trace any bad answer back to its exact prompt

Claude wraps every model, retrieval and tool call in traced, versioned spans with tokens, cost, cache reads, latency and stop reason, so any reported bad answer leads to its exact rendered prompt. Content logging follows an explicit redaction, sampling and retention policy, dashboards and alerts cover spend and truncation, and trace-linked user feedback becomes new eval cases.

llm-observability 196 lines

No. 251

Local LLMs

Size it, quantize it, benchmark it, then serve

Claude sizes memory before anything downloads, using a bundled estimator that reads the model's config to compute weights plus KV cache for your context and concurrency. It then picks a runtime and quantization, sets context length and GPU offload explicitly, benchmarks prefill and decode speed, checks quality on your own tasks and keeps the endpoint on localhost or behind auth.

local-llms 209 lines · 2 files

No. 252

MLOps Tracking

Trace any production model back to code and data

Claude wires experiment tracking so production models are traceable. Every run records commit, data version, config, environment, metrics, and evaluation artifacts under consistent names; models are logged with signatures and registered; promotion moves a champion alias only after an evaluation gate and approval; and serving loads by alias or pinned version with a documented rollback.

mlops-tracking 204 lines

No. 253

Model Serving

Self-hosted LLM endpoints sized to a real SLO

Claude deploys open-weight models like a platform engineer. It sizes GPU memory from the model config, weights, and KV cache, picks parallelism and quantization only after checking quality on your eval, tunes batching knobs with a load test shaped like real traffic, and autoscales replicas on queue depth with measured cold-start time. You end with cost per million tokens and an alert set.

model-serving 196 lines

No. 254

Multi-Agent Orchestration

Parallel agents only where they pay for themselves

Claude first checks whether multiple agents are justified at all, naming the bottleneck they remove. When they are, it writes self-contained worker briefs with scope boundaries and a result schema, fans out under a concurrency cap with cheap worker models, and synthesizes with provenance and explicit gaps. The design is kept only if it beats a single-agent baseline on quality or wall-clock.

multi-agent-orchestration 178 lines

No. 255

Prompt Caching and Costs

Cut the LLM bill with caching before downgrades

Claude profiles where tokens actually go before changing anything, then applies the no-quality-loss levers in order: stable-prefix prompt caching with correct breakpoints, the batch API for offline work, and trimmed history and tool results. A bundled cost model shows break-even hit rates and tier what-ifs, and cheaper models or lower effort ship only after passing the eval.

prompt-caching-costs 189 lines · 2 files

No. 256

Prompt Engineering

Prompts measured against evals, not eyeballed

Claude stops tweaking prompts by feel. It gathers real inputs and gradeable criteria first, drafts with a proven skeleton of tagged context, instructions, constraints and examples, then fixes failures one class at a time while re-running a held-out eval. Prompt revisions ship with a version number, a changelog line per edit and before and after scores.

prompt-engineering 200 lines

No. 257

Prompt Injection Defense

Contain what an injected instruction can do

Claude defends LLM apps on the assumption that some injection will get through. It maps every untrusted input, breaks the private data, untrusted content and egress trifecta per agent, enforces permissions and approvals in code, closes markdown-image and URL exfiltration channels, and builds an adversarial suite from a catalog of real attack categories that runs in CI.

prompt-injection-defense 169 lines · 2 files

No. 258

PyTorch Training

Overfit one batch, resume exactly, then scale

Claude writes training scripts that prove themselves on a tiny run first: overfit one batch, confirm the data loader is not the bottleneck, and verify that a resumed checkpoint reproduces the loss curve. It adds bf16 or fp16 precision, accumulation, clipping, torch.compile and DDP in the right order, and debugs NaN, flat or diverging loss with a step-by-step reference instead of random hyperparameter changes.

pytorch-training 224 lines · 2 files

★ No. 259

RAG Pipelines

Fix retrieval first, then make answers cite it

Claude treats RAG as two systems with two scorecards. It builds a labeled question set, chunks with document structure and context prefixes, retrieves with hybrid search fused by reciprocal rank and a reranker, and generates answers that cite supplied sources or abstain. A bundled script reports recall@k, MRR and nDCG so retrieval failures are fixed before anyone touches the prompt.

rag-pipelines 191 lines · 2 files

No. 260

Realtime Voice Agents

Answer fast, stop when interrupted, never talk over callers

Claude builds voice agents around a measured voice-to-voice budget rather than vendor demo numbers. It picks a cascaded or speech-to-speech design, tunes VAD or semantic turn detection, cancels and truncates speech on barge-in so history matches what the caller heard, covers slow tools with spoken filler, and replays a recorded-audio suite in real time to catch regressions.

realtime-voice-agents 221 lines · 2 files

No. 261

Recommendation Systems

Beat the popularity baseline where it counts: online

Claude builds recommenders in the order that pays off: impression logging first, popularity and co-occurrence baselines next, then candidate generators measured by recall and a learning-to-rank model with point-in-time features. It evaluates with time-based splits, watches coverage and novelty so results do not collapse onto bestsellers, handles cold start, and trusts the A/B test over offline gains.

recommendation-systems 186 lines

No. 262

Speech-to-Text

Transcripts measured by WER on your own audio

Claude builds transcription pipelines that hold up on real calls and meetings. It normalizes audio with ffmpeg, runs VAD so silence does not become invented sentences, picks a Whisper model and compute type or a hosted API, aligns word timestamps, attributes speakers with pyannote or per-channel splitting, and measures WER and CER on human references with a bundled script.

speech-to-text 190 lines · 2 files

No. 263

Structured Outputs

Schema-valid JSON, then checks on what it says

Claude replaces prompt-and-regex JSON with native constrained decoding: a JSON schema output format or strict tool generated from Pydantic or Zod models. It designs schemas with nullable fields and escape-value enums so the model never invents data, checks stop reasons before parsing, validates meaning as well as shape, and caps repair retries before routing to a human.

structured-outputs 220 lines

No. 264

Synthetic Data

Generated data that beats real-only on real tests

Claude generates synthetic datasets that have to prove themselves. It plans diversity with attribute grids and rotated real seeds, validates every row with code, scores quality with a judge calibrated against humans, and strips exact and near-duplicates plus anything overlapping your eval set using a bundled MinHash script. The data is kept only if it improves results on real held-out data.

synthetic-data 196 lines · 2 files

No. 265

Text-to-Speech

Natural voice output without seams or misreads

Claude builds TTS pipelines that sound right at scale. It picks voices through blind listening tests on your own scripts, normalizes numbers, dates, and acronyms before synthesis, uses SSML and lexicons where the provider supports them, chunks long text on sentence boundaries with a bundled script, streams sentence by sentence for agents, caches by content hash, and checks output with round-trip ASR.

text-to-speech 177 lines · 2 files

No. 266

Tool-Use Agents

Tools the model can pick right, loops that stop

Claude designs agent tools the way the model needs them: few high-level tools with descriptions that say when to use them, strict schemas, size-capped results, and errors phrased as next steps. The agent loop returns all parallel results in one message, enforces turn, token and time budgets, detects repeated calls, and gates refunds, emails and deletes behind explicit approval.

tool-use-agents 209 lines

No. 267

Vector Search

ANN tuned against exact search, with filters on

Claude picks a vector store by operational fit, creates indexes with explicit HNSW or IVFFlat parameters and filter indexes, and then proves the setup by comparing ANN results to brute-force search on real queries with production filters. It sweeps ef_search to the recall and latency knee and flags post-filtering, mixed embedding models and unnormalized vectors before they ship.

vector-search 210 lines

Choosing AI Engineering skills

Install the skills that match requests you make every week; each costs about 100 tokens of standing context until it loads. If you are not sure where to begin, start with Computer-Use Agents, LLM Batch Jobs and LLM Evals. For background, read The Best Claude Code Skills in 2026, by Use Case, How to Install Claude Code Skills (5 Ways) and Personal vs Project Skills.

By technology: LLM and AI apps skills Python skills

Install several

Install several at once

The installer accepts any number of skill names. Add --project to install into the current repository.

curl -fsSL https://claudeskills.page/install.sh | sh -s -- agent-memory computer-use-agents computer-vision content-moderation document-extraction-llm fine-tuning huggingface-transformers image-generation llm-app-builder llm-batch-jobs llm-classification llm-evals llm-gateway-routing llm-observability local-llms mlops-tracking model-serving multi-agent-orchestration prompt-caching-costs prompt-engineering prompt-injection-defense pytorch-training rag-pipelines realtime-voice-agents recommendation-systems speech-to-text structured-outputs synthetic-data text-to-speech tool-use-agents vector-search

AI Engineering skills FAQ

How do I install every AI Engineering skill at once?

Download the bundle at https://claudeskills.page/downloads/category/ai-ml.zip and unzip it into ~/.claude/skills/ (or .claude/skills/ inside a repository). To pick a few, pass several names to the installer: curl -fsSL https://claudeskills.page/install.sh | sh -s -- agent-memory computer-use-agents computer-vision.

Will installing 31 skills slow Claude Code down?

No. Claude Code keeps only each skill's short description in context — roughly 100 tokens per skill — and loads the full instructions only when a request matches. Install the whole category if it fits your work; unused skills cost almost nothing.

Which AI Engineering skill should I start with?

Start with Computer-Use Agents, LLM Batch Jobs, LLM Evals. They cover the most common requests in this category; add the rest as your work calls for them.