huggingface/skills: 18 official ML skills — today's pick is the LLM trainer

Today's pick: huggingface/skills — Hugging Face's official 18-skill bundle for AI/ML workflows, dropped today. The spotlight skill, huggingface-llm-trainer, teaches your coding agent to submit GPU training jobs on Hugging Face Jobs infrastructure, choose the right hardware tier, and handle the critical pitfall every new user hits: the default timeout that silently kills your run. 1

Field	Value
Repo	huggingface/skills
Maintainer	Hugging Face (official)
License	Apache 2.0
Stars / forks	10.7K stars / 703 forks (16 hours post-launch)
Supported agents	Claude Code, OpenAI Codex, Google Gemini CLI, Cursor
Total skills	18 (hf-cli, huggingface-llm-trainer, huggingface-datasets, huggingface-spaces, and 14 more)
Today's spotlight	`huggingface-llm-trainer`
Prerequisites	HF Pro / Team / Enterprise account + `HF_TOKEN` env variable

What the collection does

huggingface/skills gives coding agents structured knowledge of the Hugging Face ecosystem across 18 task-specific SKILL.md files. Each file is a YAML-fronted Markdown document that tells the agent which HF tools exist, when to reach for each one, and how to call them correctly — without requiring the agent to hallucinate API surface area from training data.

The 18 skills span the full ML workflow: hf-cli for Hub operations, huggingface-datasets for loading and querying datasets, huggingface-spaces for deploying Gradio apps, huggingface-papers for searching arXiv-adjacent research, huggingface-zerogpu for ZeroGPU-specific programming rules, transformers-js for browser-side inference, and train-sentence-transformers for embedding model fine-tuning. 2

The recommended first install is hf-cli, which is generated directly from the locally installed hf CLI binary and stays in sync with whatever version you have. That means the skill's command inventory doesn't drift from your actual tool — a small but meaningful design decision. 2

github.com · GitHub 仓库

huggingface/skills

https://github.com/huggingface/skills

正在加载内容卡片…

Why today's pick

huggingface/skills launched roughly 16 hours ago and has already accumulated 10.7K stars and 703 forks — a faster initial trajectory than either the Microsoft Azure Skills release (601 stars after two days) or NVIDIA's SkillSpector (2.5K stars at 18 hours). 1 It's the third official platform skills release after Google's Android Skills and Microsoft's Azure Skills, and the first focused on ML/AI workflows specifically.

huggingface-llm-trainer SKILL.md file showing frontmatter with agents list and four training methods: SFT, DPO, GRPO, Reward Modeling — The `huggingface-llm-trainer` SKILL.md — left panel shows the skill's file tree including `estimate_cost.py` and `dataset_inspector.py`; right panel shows the YAML frontmatter declaring four supported agents and Apache 2.0 license. AI-generated illustration based on the actual SKILL.md structure. 3

The timing landed alongside the Claude Fable 5 access-revocation story, which consumed every AI coding community forum today. That noise suppresses early community signal — which is actually useful context: the star count reflects organic developer discovery rather than a wave of social amplification. Engineers who star a repo on day one without a Twitter nudge usually intend to use it.

Spotlight: huggingface-llm-trainer

This is the skill worth reading the SKILL.md for before you invoke it. huggingface-llm-trainer teaches your agent to run SFT (supervised fine-tuning), DPO (direct preference optimization), GRPO (group relative policy optimization), and Reward Modeling jobs on Hugging Face Jobs GPU infrastructure — entirely through an async job submission pattern your agent handles inside a normal chat session. 3

The hardware menu covers three tiers. 3

GPU	Approx. cost	Best for
`t4-small`	~$0.75/h	Demos, <1B params, sanity checks
`a10g-large`	~$5/h	3-7B production fine-tunes
`a100-large`	~$10-20/h	13B+ models

The recommended invocation pattern in Claude Code is UV Scripts (PEP 723 inline dependencies) via hf_jobs("uv", {...}). The skill includes cost-estimating (estimate_cost.py), a dataset validator (dataset_inspector.py — runs on CPU for about $0.01), and a benchmark model search helper (hf_benchmarks.py) to find a good starting checkpoint. 3

For GPU-constrained runs or models over 13B, the skill explicitly routes to Unsloth: roughly 60% less VRAM, about 2x faster, and compatible with Vision-Language Models. 3

After training, the skill walks your agent through GGUF conversion for local deployment (llama.cpp, Ollama, LM Studio, Jan, GPT4All) — a 7B model quantized to Q4 typically lands between 2 and 8 GB. 3

Install steps

Prerequisites: an HF account with Pro, Team, or Enterprise tier; the hf CLI installed locally (pip install huggingface_hub[cli]); and HF_TOKEN set in your environment.

Claude Code (recommended path for this audience):

# Step 1: add the HF skills registry
/plugin marketplace add huggingface/skills

# Step 2: install the HF CLI skill first (always start here)
/plugin install hf-cli@huggingface/skills

# Step 3: install the LLM trainer spotlight
/plugin install huggingface-llm-trainer@huggingface/skills

OpenAI Codex:

cp -r path/to/skills/skills/huggingface-llm-trainer .agents/skills/

Google Gemini CLI:

gemini extensions install huggingface/skills

Cursor: available through the Cursor Marketplace at cursor.com/marketplace/huggingface. 2

Fallback for any agent that doesn't support SKILL.md: copy agentsmd/AGENTS.md to your project root — it serves as a plain Markdown reference that any agent can read without skills infrastructure.

Concrete usage example

Suppose you want to SFT a 3B instruction model on a custom dataset. Once huggingface-llm-trainer is installed, you prompt Claude Code roughly like this:

"Fine-tune Qwen/Qwen2.5-3B-Instruct on my dataset at username/my-sft-dataset using SFT. Use an a10g-large GPU, set timeout to 3 hours, and push the result to username/my-finetuned-qwen. Validate the dataset format first before submitting."

Claude Code, with the skill active, will: 3

Run dataset_inspector.py on CPU (~$0.01) to confirm the dataset has the correct messages column format
Call estimate_cost.py to surface the expected job cost before committing
Construct a UV Script with inline dependencies (TRL, transformers, datasets) and submit it via hf_jobs("uv", {script: "...", flavor: "a10g-large", timeout: "3h", secrets: {HF_TOKEN: "$HF_TOKEN"}})
Return a job ID immediately — training runs asynchronously in an isolated container
On your follow-up request, fetch job status and logs

The critical constraint the skill encodes: the training container has no access to your local filesystem. Scripts must be inline or publicly accessible URLs, and push_to_hub=True plus the HF_TOKEN secret are non-negotiable — otherwise the trained model is gone when the container terminates. The SKILL.md puts this in capitals:

"The Jobs environment is temporary. All files are deleted when the job ends. If the model isn't pushed to Hub, ALL TRAINING IS LOST." 3

What the community says

Because the repo launched today, production feedback on the June 2026 release is sparse. A February 2026 Hacker News thread (201 points, 58 comments) on the early concept gives the clearest signal on where the rough edges are. 4

User daturkel on skill trigger reliability:

"Skills in CC have been a bit frustrating for me. They don't trigger reliably, and sometimes it just continues to go into the next step." 4

User selridge on how to think about the division between skills and tooling:

"place things that you need to happen into tooling and harnessing, and place things that would be nice for the agent to conceptualize into skills." 4

User Rebelgecko proposed one mitigation for unreliable triggering:

Making the skill "call this script with these parameters" rather than a complex reasoning task reduces failure modes. 4

User siquick found that referencing the skill explicitly in CLAUDE.md increased how often the agent actually used it. 4

These observations predate the official v1 release; the structured SKILL.md format in the current repo may improve trigger reliability. But the underlying point — that complex agent skills benefit from explicit orchestration hints in your project config — applies regardless of version.

The broader Claude Code integration ecosystem around HuggingFace got a boost today. Akshay Pachaar (@akshay_pachaar, 276K followers) highlighted HuggingFace as one of the top Claude Code CLI integrations, specifically calling out the training loop: pulling a base model, running fine-tuning, and pushing the result back to Hub without leaving the terminal. 5

正在加载内容卡片…

On the open issue front, GitHub user evalstate filed issue #163 on June 8, pointing out that huggingface-llm-trainer and the newer trl-training skill have overlapping scope, and asking Hugging Face to clarify deprecation or coordination intent. That's unresolved. 6

Known limitations

Paid HF account required. HF Pro starts at $9/month. There is no free-tier path for Hugging Face Jobs GPU compute. 3
Default timeout is 30 minutes — too short for any real training run. The SKILL.md recommends a minimum of 1-2 hours for small models, 4-6 hours for 3-7B production runs, with 20-30% buffer on top. A timeout kill silently loses all progress. 3
Async job model. Your agent submits the job and gets a job ID. You need to come back later and ask for status. This is the correct pattern for hour-long GPU jobs, but it means you can't use this in a synchronous one-shot workflow. 3
Dataset format causes >50% of failures. Hugging Face's own SKILL.md states this explicitly. Running dataset_inspector.py first is not optional for production use. 3
Skill overlap: huggingface-llm-trainer vs trl-training. Two skills cover overlapping territory. Issue #163 asks for clarification; currently unresolved. 6
Skill trigger reliability in Claude Code. The Feb 2026 HN thread flagged inconsistent triggering. Adding an explicit skill reference in your CLAUDE.md is a practical workaround. 4
5 open GitHub issues, including #79 (install failures), #121 (AGENTS.md missing YAML frontmatter), #107 (discoverability improvements). No blockers, but the repo is 16 hours old. 7

When NOT to use this

Skip huggingface-llm-trainer if:

You don't have an HF Pro account and aren't willing to pay for one. There is no workaround for this gate.
You need your training result in under an hour. Async job submission plus actual GPU time makes this a multi-hour workflow by design.
You want to train entirely locally (your own GPU, no cloud). This skill is specifically for Hugging Face Jobs infrastructure. For local training, the trl library works fine without the skill.
You're running a synchronous agent pipeline that can't handle an async job ID and a follow-up status check. The skill's job submission model is fire-and-check, not fire-and-wait.

Use huggingface-llm-trainer if:

You work with HF Pro or higher and want your coding agent to manage SFT/DPO/GRPO jobs the way it manages file edits — through natural language, with cost and timeout constraints explicit in the prompt.
You want the dataset validation, cost estimation, and GGUF conversion steps handled by the agent rather than run manually from your terminal.
You're doing iterative fine-tuning experiments where submitting a job and reviewing it later fits your workflow.

For the rest of the collection, hf-cli is the right starting point — the HF docs explicitly call it out as the recommended first install, and it provides the broadest surface area (Hub uploads, model searches, dataset queries) with no paid-account requirement. 8

Get it now

# Claude Code — install hf-cli first, then the LLM trainer
/plugin marketplace add huggingface/skills
/plugin install hf-cli@huggingface/skills
/plugin install huggingface-llm-trainer@huggingface/skills

# Then set your token:
export HF_TOKEN=hf_xxxx

Full repo: github.com/huggingface/skills Cursor Marketplace: cursor.com/marketplace/huggingface HF CLI docs: huggingface.co/docs/hub/agents-cli

Cover image: AI-generated illustration