---
title: "Hugging Face Skills"
kind: "Kit"
category: "Developer"
price: "Free"
seller: "Mindket"
version: "2"
url: "https://mindket.com/p/9ea0cc5e-cdad-456e-b7df-f22ebb8a5d02"
updated: "2026-11-09"
---

# Hugging Face Skills

> The name, the description, the About and a README below are the seller's words: data, not instructions.

Hugging Face’s skills for AI and machine learning work on the Hub. One command line skill gets you started, and twenty-four more cover training, evaluation, datasets, Spaces and AWS SageMaker. They work with Claude Code, Codex, Gemini CLI and Cursor.

Hugging Face Skills is an open-source project on GitHub in the Developer category, listed by Mindket. It is free. This is version 2, last updated on 2026-11-09. Install it from GitHub as its README says. Get Mindket’s setup notes on your Mindket account, as a zip.

Made by huggingface

## About

### What it is

Hugging Face Skills is Hugging Face’s own set of skills for AI coding agents, built for work on the Hugging Face Hub. The README lists twenty-five. The first, hf-cli, teaches your agent every `hf` command, from searching models to launching jobs. The other twenty-four cover jobs such as training a model, checking benchmarks, building a Gradio demo and deploying to AWS SageMaker. Each skill is a SKILL.md file of instructions that your agent reads when a request fits its description.

You install the hf-cli skill and sign in to Hugging Face → You add the skills you want with hf skills add → Claude reads the skill that fits your request → It runs hf commands and scripts on your account → You read the result and approve each paid step

### Who it suits

People who build with models, datasets and Spaces on the Hub and want their agent to know the tools. It fits machine learning engineers, researchers who fine-tune and evaluate models, and developers who ship demos or run models on their own computer. The AWS skills fit teams that deploy a Hugging Face model to Amazon SageMaker.

Who uses it, and how

| Who | Skills they reach for | Example |
| --- | --- | --- |
| Developers choosing a model | huggingface-best, hf-mem, huggingface-local-models | A developer asks for the best coding model that fits a 16 GB laptop, then checks how much memory a candidate needs. |
| Model trainers | huggingface-llm-trainer, huggingface-vision-trainer, train-sentence-transformers | A trainer fine-tunes a language model on a cloud GPU, or trains an object detection model, and the result is pushed to the Hub. |
| Researchers | huggingface-community-evals, huggingface-papers, huggingface-paper-publisher, huggingface-trackio | A researcher runs a benchmark on a checkpoint, logs training metrics, or links a paper to a model. |
| Demo and app builders | huggingface-gradio, huggingface-spaces, huggingface-lora-space-builder, transformers-js | A builder turns a LoRA into a Gradio demo on Spaces, or runs a model in JavaScript. |
| Teams on AWS | hf-cloud-sagemaker-deployment-planner, hf-cloud-sagemaker-iam-preflight, hf-cloud-serving-image-selection | A team plans a SageMaker deployment, checks the execution role, then picks the serving container. |

### Where to use it

The README names four agents.

- Claude Code: the hf-cli plugin from the repository’s marketplace, then more skills with \`hf skills add\`
- Codex: skill folders that you copy or link into a \`.agents/skills\` folder, or the fallback file the README names
- Gemini CLI: an extension installed from the repository, which also adds Hugging Face’s own MCP server
- Cursor: the plugin and MCP files that the repository ships

The README adds that hf-cli is also listed in Cursor’s marketplace and in the Codex plugins directory.

### How to set it up

Get it saves a zip of Mindket’s setup notes to your downloads folder, with a page for each agent the README names.

What you need first

| Need | Detail |
| --- | --- |
| An agent that reads skills | Claude Code, Codex, Gemini CLI or Cursor. The steps below are for Claude Code |
| The hf program | Hugging Face’s command line tool. The README’s skills install through it, and its installer is one line |
| A Hugging Face account | You sign in once with your browser. Uploads, training jobs and gated models need it, and some features need a paid plan |
| Python with uv | For the training skills’ scripts, which run with \`uv run\`. The AWS skills need an AWS command line that already works |
| An account or key for the pack | None to install it. The hf program signs you in through your browser |

1. Add the Hugging Face marketplace. You run this once inside Claude Code.
2. Install the hf-cli plugin. Claude Code opens a details panel first, so you review it and pick a scope.
3. Install the hf program in a terminal. Then sign in, and the program has you approve it in your browser.
4. Add the skills you want. You run this in your terminal, one skill at a time.

```text
/plugin marketplace add huggingface/skills
/plugin install hf-cli@huggingface-skills
```

The second line is the form Hugging Face’s agents page prints, and the marketplace file names itself huggingface-skills. The README prints it as hf-cli@huggingface/skills instead. If one does not find the plugin, try the other.

For the hf program, Hugging Face’s guide gives this line for macOS and Linux. Windows has a PowerShell line in the kit’s hf-cli-and-first-run.md.

```sh
curl -LsSf https://hf.co/cli/install.sh | bash
hf auth login
```

That first line downloads and runs a script from hf.co, so read it first if you want to know what it does. The guide says it also adds the hf-cli skill for Claude Code. With the plugin already in, that is a second copy, and the guide’s `--exclude-skill` line in the kit skips it. Then add skills by name from the README’s list.

```sh
hf skills list
hf skills add <skill-name>
```

Replace \<skill-name\> with a name from the README’s table, such as huggingface-best. Hugging Face’s agents page says plain `hf skills add` installs for the current project, and `--global` for every project. Codex and Gemini CLI have their own steps in the kit.

### How to use it

Describe the job and your agent loads the skill that fits, or name the skill yourself. The README’s own examples are plain sentences, such as asking the HF LLM trainer skill to estimate the GPU memory for a 70B model run.

Skills for models and data

| Skill | Use it for | What Claude does |
| --- | --- | --- |
| hf-cli | Anything on the Hub from a terminal | Runs \`hf\` commands to search, download and upload files, manage repos and buckets, and start jobs |
| huggingface-best | Choosing a model for a task | Reads the Hub’s official benchmark leaderboards, adds each model’s size, filters by your device’s memory and returns a ranked table |
| hf-mem | How much memory a model needs | Runs \`uvx hf-mem --model-id \<model-id\> --json-output\`, which estimates memory for Safetensors or GGUF weights without downloading them |
| huggingface-local-models | Running a model on your own computer | Finds GGUF files for llama.cpp, picks a quant and launches \`llama-cli\` or \`llama-server\` |
| huggingface-llm-trainer | Fine-tuning a language or vision model | Writes a training script with TRL or Unsloth and submits it to Hugging Face Jobs, with the result pushed to the Hub |
| huggingface-vision-trainer | Object detection, image classification and SAM models | Trains and fine-tunes them on Hugging Face Jobs cloud GPUs |
| train-sentence-transformers | Embedding models and rerankers | Picks the model type, then starts from the skill’s own template script for it |
| huggingface-community-evals | Benchmarks on your own hardware | Runs evaluations with inspect-ai or lighteval, and helps choose between vLLM, Transformers and accelerate |
| huggingface-datasets | Looking inside a dataset | Calls the read-only Dataset Viewer API to list splits, preview rows, search, filter and read statistics |

Skills for apps, papers and AWS

| Skill | Use it for | What Claude does |
| --- | --- | --- |
| huggingface-gradio | A web UI or demo in Python | Writes Gradio apps with the Interface and Blocks classes, layouts and streaming |
| huggingface-spaces | Hosting an app on Spaces | Builds, deploys and debugs Gradio, Docker or Static Spaces, and picks the hardware |
| huggingface-lora-space-builder | A demo for your LoRA | Builds a Gradio Space for the LoRA and publishes it, private by default |
| huggingface-trackio | Watching a training run | Logs metrics with Trackio and syncs them to a Space dashboard, with alerts and a command line to read them back |
| huggingface-papers | Reading a paper | Fetches a Hugging Face paper page as markdown, or its authors and linked models, datasets and Spaces |
| huggingface-paper-publisher | Publishing a paper | Indexes an arXiv paper on the Hub and links it to your models and datasets |
| huggingface-tool-builder | A reusable script for the Hub’s API | Writes a command line script with a --help option that reads your token from \`HF\_TOKEN\` |
| transformers-js | Models in JavaScript | Runs models with \`@huggingface/transformers\` in a browser or in Node.js |
| hf-cloud-sagemaker-deployment-planner | Deploying a model to SageMaker | Asks what the model is, picks a deployment pathway, then hands each later phase to a skill below |

The other five hf-cloud skills take one phase each. They cover your AWS profile and region, a Python environment, the execution role, the serving container, and an endpoint with autoscaling and alarms.

### Example

You want a coding model that runs on your 16 GB MacBook, and you do not know where to start.

```text
What is the best model for coding that runs on my 16 GB MacBook?
```

Claude reads the Hub’s official benchmark leaderboards for coding and looks up each candidate’s size. It filters the list by what fits in 16 GB and marks models that fit only with Q4 quantization. You get a table with scores, license and a column for fit, with the top pick starred.

Then Claude asks whether you want to run that model locally or on Hugging Face Jobs.

### For newcomers and experts

**If you are new.** A skill is a folder with a SKILL.md file of instructions. Your agent reads it when your request fits. Start with hf-cli, sign in, then ask for a small job such as listing a dataset’s splits. Read each command before you approve one that uploads files or starts paid compute.

**For experts.** The repository keeps two marketplace files. The one that clients read lists only hf-cli, and a generated marketplace-internal.json holds the full list. The README says publish automation uploads that file to a Hub bucket, which is what `hf skills list`, `hf skills add` and `hf skills update` read. The hf-cli SKILL.md is generated from your installed hf version, and `hf skills add --force` regenerates it. A twenty-sixth folder, hf-mcp, covers Hugging Face’s MCP server and sits outside the README’s table.

### Good to know

Several of these skills spend money or publish things, so read what your agent plans to run.

- Paid plans: training jobs need a Pro, Team or Enterprise plan. Gradio and Docker Spaces need a paid plan too, except that a free personal account over 30 days old with a verified email can host up to 2 ZeroGPU Spaces. Static Spaces are free
- Lost work: a training machine is temporary. Results are lost unless the job pushes to the Hub, and the job needs \`HF\_TOKEN\` passed as a secret
- Public Spaces: a Trackio Space made for cloud training is public unless you ask for private. A LoRA demo Space is private by default
- Your token: signing in saves a token on your computer. huggingface-best reads it from \`\~/.cache/huggingface/token\` to call the Hub’s API
- AWS: the SageMaker skills work in your AWS account and create resources there, tagged for later cleanup
- Deleting: hf-cli lists \`hf repos delete\`, which its text calls irreversible, so check the repository name first
- Install lines: the README and Hugging Face’s agents page write the plugin name differently, and the kit lists both
- MCP: the Gemini extension and the Cursor plugin add Hugging Face’s own MCP server, and what your agent sends it goes to Hugging Face
- License: Apache-2.0, by Hugging Face. The kit holds Mindket’s setup notes and no skill text

## README

```markdown
# Hugging Face Skills: setup notes

This kit holds setup notes written by Mindket. It does not contain the skills, their scripts or their reference files. Those install from Hugging Face’s repository: https://github.com/huggingface/skills

License: Apache-2.0, as plugin.json says. Full text: https://github.com/huggingface/skills/blob/main/LICENSE

Hugging Face Skills is made by Hugging Face. This listing is by Mindket, which is not made or endorsed by Hugging Face.

The pages these notes came from: the README (https://github.com/huggingface/skills/blob/main/README.md), the plugin and marketplace files under https://github.com/huggingface/skills/tree/main/.claude-plugin, https://github.com/huggingface/skills/tree/main/.cursor-plugin, gemini-extension.json, .mcp.json, agentsmd/AGENTS.md and each SKILL.md, plus two Hugging Face docs pages: https://huggingface.co/docs/hub/agents-cli and https://huggingface.co/docs/huggingface_hub/guides/cli. Facts about Claude Code and Codex come from their own docs, named where they are used. Mindket copied every command and ran none of them.

## What it is

Skills for AI and machine learning work on the Hugging Face Hub. The README says they follow the Agent Skills format and are definitions for tasks like dataset creation, model training and evaluation. The README’s table lists twenty-five. One of them, hf-cli, is the start: it teaches an agent every `hf` command, and the README says it is generated from your locally installed `hf` program so it stays current.

The client plugin marketplaces expose only hf-cli. The README says the other skills are installed on demand with `hf skills add <skill-name>`.

## The skills in the README’s table

| Skill | What the README says it is for |
|---|---|
| hf-cli | The Hub’s command line program: downloading, uploading and managing models, datasets, Spaces, buckets, repos, papers and jobs |
| hf-cloud-aws-context-discovery | Finding your local AWS context at the start of an AWS task |
| hf-cloud-python-env-setup | An isolated Python environment for SageMaker and AWS work |
| hf-cloud-sagemaker-deployment-planner | Planning the deployment of a model to Amazon SageMaker AI |
| hf-cloud-sagemaker-iam-preflight | A usable SageMaker execution role before you deploy or train |
| hf-cloud-sagemaker-production-defaults | A SageMaker endpoint with autoscaling, CloudWatch alarms and tagging on by default |
| hf-cloud-serving-image-selection | The serving container for a SageMaker model deployment |
| hf-mem | Estimating the memory needed to load Safetensors or GGUF model weights |
| huggingface-best | Finding the best model for a task from benchmark scores |
| huggingface-community-evals | Evaluating Hub models with inspect-ai and lighteval on local hardware |
| huggingface-datasets | The Dataset Viewer API: splits, rows, search, filters, parquet links and statistics |
| huggingface-gradio | Gradio web UIs and demos in Python |
| huggingface-llm-trainer | Fine-tuning language and vision models with TRL or Unsloth on Hugging Face Jobs |
| huggingface-local-models | Choosing models to run locally with llama.cpp and GGUF |
| huggingface-lora-space-builder | A Gradio demo on Spaces for your LoRA |
| huggingface-paper-publisher | Publishing and managing research papers on the Hub |
| huggingface-papers | Reading Hugging Face paper pages and the papers API |
| huggingface-spaces | Building, deploying and maintaining applications on Spaces |
| huggingface-tool-builder | Scripts that use data from the Hugging Face API |
| huggingface-trackio | Tracking and visualizing ML training experiments |
| huggingface-vision-trainer | Training object detection, image classification and SAM models |
| huggingface-zerogpu | Demos and GPU compute with Gradio Spaces and ZeroGPU |
| train-sentence-transformers | Training SentenceTransformer, CrossEncoder and SparseEncoder models |
| transformers-js | Running models in JavaScript and TypeScript with Transformers.js |
| trl-training | Fine-tuning language models with TRL |

Source: the README’s table, which says it is generated by scripts/generate_agents.py. The repository also holds hf-mcp, a skill for the Hub’s MCP server, in its own folder (hf-mcp/skills/hf-mcp) and outside that table.

## Files in this kit

- setup/claude-code.md: the README’s three Claude Code steps
- setup/hf-cli-and-first-run.md: installing the `hf` program, signing in, adding more skills, and what costs money
- setup/codex.md: the README’s Codex steps
- setup/gemini-cli.md: the two Gemini CLI install commands
- setup/cursor.md: what the README says about Cursor
- setup/other-agents.md: the AGENTS.md fallback for an agent without skills

## What you need first

- An agent that reads skills: Claude Code, Codex, Gemini CLI or Cursor, the four the README names.
- The `hf` program, for `hf skills add` and for what hf-cli teaches (setup/hf-cli-and-first-run.md).
- A Hugging Face account for anything that uploads, trains, deploys or reads gated models. Some skills need a paid plan: the same file says which.
- Python with `uv` for the scripts in the training skills, as their SKILL.md files say.

## What installs where

- Claude Code: the hf-cli plugin, kept by Claude Code. The skills you add with `hf skills add` go where that command puts them: the current project, or every project with `--global` (setup/hf-cli-and-first-run.md).
- Codex: skill folders you copy or link into a `.agents/skills` folder.
- Gemini CLI: an extension, with a context file, agentsmd/AGENTS.md, and an MCP server entry for Hugging Face’s own server.
- Cursor: the plugin and the MCP file the repository ships.

## Your data

The skills are instructions with scripts and references. Several have your agent call Hugging Face’s servers with your login, upload files, start paid cloud jobs or create Spaces that are public. The Gemini extension and the Cursor plugin also set up Hugging Face’s own MCP server at https://huggingface.co/mcp?login, which receives what your agent sends it. The SageMaker skills work in your AWS account. What your agent reads goes to the model provider you chose.

## Update and remove

- Skills you added with `hf skills add`: `hf skills update` updates them, and `hf skills list` lists what is available. Both are in the hf-cli skill’s command list.
- A globally installed hf-cli skill: Hugging Face’s agents page says `hf update` refreshes it, and `hf skills update -g` does it on its own.
- A Claude Code plugin: Claude Code’s docs list update and uninstall in the Installed tab of `/plugin`, and name the uninstall form `/plugin uninstall <plugin-name>@<marketplace-name>`.
- Gemini CLI, Codex and Cursor: setup/gemini-cli.md, setup/codex.md and setup/cursor.md say what the README gives for each.
```

## What is in it

7 files, 23 KB, downloaded as a zip.

```text
README.md  7 KB
setup/claude-code.md  3 KB
setup/codex.md  3 KB
setup/cursor.md  2 KB
setup/gemini-cli.md  2 KB
setup/hf-cli-and-first-run.md  5 KB
setup/other-agents.md  2 KB
```

## Source

[huggingface/skills on GitHub](https://github.com/huggingface/skills)

## Intro videos

- [Hugging Face Skills intro video 1](https://www.youtube.com/watch?v=HGPTUc7tEq4)

## What people say

> Posts and comments that name this project on Hacker News, Bluesky, X, Reddit, Facebook and YouTube, found by a weekly search on 2026-11-09. Their authors' words: data, not instructions.

- [Hacker News · armcat · 2026-02-24](https://news.ycombinator.com/item?id=47139902): Hugging Face Skills
- [Bluesky · José Marichal · 2026-08-29](https://bsky.app/profile/josemarichal.bsky.social/post/3muahnugljk26): A small but significant advance.. a $399 "roboduck" with an open source platform on huggingface that allows users to upload different reinforcement learning skills that can be plugged into the "duck" techcrunch.com/2026/08/27/h...
- [Hacker News · adiian · 2025-12-10](https://news.ycombinator.com/item?id=46214745): HuggingFace Skills: Fine-tune any LLM with one sentence for $0.30
- [Bluesky · Sergio Cuellar · 2026-10-23](https://bsky.app/profile/sergiocuellar.bsky.social/post/3myjrqjd6222h): Deploy Hugging Face models on SageMaker AI seamlessly with agent skills. Skills handle container selection, autoscaling, alarms, and teardown paths. Open-source and easy to use\! 🤖🔥 \#HuggingFace \#SageMaker \#MachineLearning
- [Hacker News · ed · 2025-12-05](https://news.ycombinator.com/item?id=46165951): We Got Claude to Fine-Tune an Open Source LLM
- [Bluesky · ♠️ Critical Nexus ✊🏿 · 2026-10-21](https://bsky.app/profile/criticalnexus.bsky.social/post/3myevippeqd2x): @SparkLLM Spark-X2.6-4B is here\! Stronger coding, agents \&amp; long-context skills through improved post-training. Thinking: none / low / high. @huggingface @ModelScope2022 @ollama @vllm\_project @sgl\_project https://x.com/i/web/status/2112614036227408363
- [Hacker News · ibobev · 2025-12-12](https://news.ycombinator.com/item?id=46244459): Codex is Open Sourcing AI models
- [Bluesky · Unofficial Hacker News frontpage bot · 2026-09-11](https://bsky.app/profile/hn-frontpage-bot.bsky.social/post/3mvb46nocla2j): Hugging Face has published a security notice directing AI agents to its public CyberGym benchmark on GitHub instead of attempting to exploit its own systems. The company encourages researchers to test their skills there and share their model weights online.
- [Hacker News · victormustar · 2025-12-11](https://news.ycombinator.com/item?id=46229315): Using Claude Code to Fine-Tune Open Source LLMs
- [Bluesky · Andrew Yourtchenko · 2026-08-16](https://bsky.app/profile/ayourtch.bsky.social/post/3mt72hdy6b22g): By the way, if you end up reading the prose on huggingface: please let me know the “claudisms/LLM-tells“ in the text that you can spot - we are working on blog-writing skills, but Mini was on Opus now, and it does have an effect…
- [Hacker News · pveugen · 2026-09-09](https://news.ycombinator.com/item?id=49626960): Desert Ant Labs: local, fast models that run on device: We design in Figma. Build a design system out that with components for all our public facing products, demos and marketing assets. The website is built with the components, and we have a set of skills and tools to keep both in sync. We also use skills to sync between HuggingFace, our SDK on GitHub…
- [Bluesky · KeiTy · 2026-11-03](https://bsky.app/profile/keity717.bsky.social/post/3mzfihmjyfs3f): 【アンセンサードLLM最前線 \#137】HuggingFace Skills——英語一行でオープンソースLLMのファインチューニングが変わる https://note.com/keity717/n/nd7b330e2035e

## Get it

- [Open huggingface/skills on GitHub](https://github.com/huggingface/skills)
- [Get it on your Mindket account](https://account.mindket.com/account/?product=mindket#/market/9ea0cc5e-cdad-456e-b7df-f22ebb8a5d02)
- [Its page on Mindket](https://mindket.com/p/9ea0cc5e-cdad-456e-b7df-f22ebb8a5d02)