What does this skill do, and when should you use it?
This skill teaches an AI assistant to run workloads on Hugging Face Jobs infrastructure. It covers two submission approaches — UV scripts with PEP 723 inline dependencies and Docker-based jobs — plus a hardware selection table (from cpu-basic up to a100-large and TPUs), cost estimation guidance, and timeout rules. Three critical practices are emphasized throughout: passing HF_TOKEN securely via secrets, always persisting results from the ephemeral environment, and setting adequate timeouts for long tasks. It also ships three ready-to-run scripts (vLLM batch generation, CoT synthetic data, streaming dataset stats) and documentation for scheduled jobs and webhook triggers.
Submits jobs to Hugging Face Jobs via the hf_jobs() MCP tool (or equivalent hf CLI / huggingface_hub Python API): passing Python scripts as inline strings, local file contents, or URLs, with a chosen hardware flavor, timeout, and secrets. Jobs run on cloud CPUs/GPUs/TPUs; scripts use HF_TOKEN to push models, datasets, or files to the Hub, or upload to external storage like S3. It supports monitoring via hf_jobs("ps"/"inspect"/"logs"/"cancel"), CRON-based scheduled jobs, and webhook-triggered runs. The skill bundles reference guides (tokens, hardware, Hub persistence, troubleshooting) and three reusable UV scripts.
- A developer without a local GPU running batch inference: submit a vLLM script on a10g-large to generate responses for thousands of samples and push the output dataset back to the Hub
- A researcher generating synthetic training data: run cot-self-instruct.py to produce reasoning Q&A pairs, filter with answer-consistency, and publish as a Hub dataset
- A data engineer computing stats over a large parquet dataset on the Hub: stream it with finepdfs-stats.py using Polars, avoiding a 300GB download
- A team needing recurring tasks: schedule inference or data-processing jobs with CRON expressions or @hourly, with suspend/resume controls
- A practitioner fine-tuning or benchmarking models without local compute: pick t4/a10g/a100 flavors by model size and run reproducible experiments in the cloud
- A user who wants automatic processing when a repo changes: configure webhooks so Hub events trigger jobs
How do you install this skill?
- Core function depends entirely on Hugging Face Hub/Jobs and a paid plan; mainland-China reachability is questionable and the paywall is not surfaced at trigger time.
- The skill directs the agent to submit arbitrary scripts to paid cloud compute incurring real cost—confirm budget expectations; the RIP filter script is a placeholder whose behavior does not match the claimed paper methodology.
- No versioning or changelog; hardware pricing and flavor lists may be stale—verify against current official HF docs.
- Static review only; no code was executed and example usability is not independently verified.
- Shell / CLI
- Network access
- Local filesystem
- MCP Server
hf_jobs() MCP tool (or `hf` CLI with huggingface_hub)Hugging Face Pro/Team/Enterprise planHF_TOKEN with appropriate permissions
The source gives no standalone install steps. The skill lives at hugging-face-skills/skills/hugging-face-jobs/ in patchy631/ai-engineering-hub, part of a 10-skill collection (MIT licensed). As a Claude Code skill, the usual approach is placing the skill folder into your skills directory; the repo provides no skill-specific install command. Prerequisites you must arrange yourself: a Hugging Face Pro/Team/Enterprise paid plan (Jobs requires a paid plan), an active hf auth login, and an HF_TOKEN with the needed read/write permissions.
tmp="$(mktemp -d)"
git clone --depth 1 https://github.com/patchy631/ai-engineering-hub.git "$tmp"
mkdir -p ~/.claude/skills
cp -R "$tmp/hugging-face-skills/skills/hugging-face-jobs" ~/.claude/skills/
rm -rf "$tmp"Generated from the source repository and skill path; it copies only this skill's folder. If the author's install steps above differ, follow those first. To scope it to one project, replace ~/.claude/skills with that project's .claude/skills.
How do you use this skill?
Once installed, send your agent any of these to trigger it:
- <inline Python code or script URL>
Trigger it whenever the user mentions running jobs on Hugging Face infrastructure, needing cloud GPUs, or running workloads without local setup. Core usage: submit via the hf_jobs() MCP tool, e.g. hf_jobs("uv", {"script": "<inline Python code or script URL>", "flavor": "a10g-large", "timeout": "4h", "secrets": {"HF_TOKEN": "$HF_TOKEN"}}). Note that in inline mode the script parameter cannot be a local filesystem path (the remote container can't see it) — pass file contents or a URL; the hf jobs uv run CLI does accept local paths. After submission you get a job ID and monitoring URL (https://huggingface.co/jobs/username/job-id); check status with hf_jobs("ps") or hf_jobs("logs", {"job_id": "..."}). Before any Hub-writing or private-repo task, pass HF_TOKEN via secrets and persist results before the script ends — the environment is ephemeral and unsaved work is lost.
What are this skill's strengths and limitations?
- Comprehensive coverage: hardware table, cost estimation, timeout rules, token security, and failure-mode troubleshooting in one place
- Three ready-to-run scripts (vLLM batch generation, CoT synthetic data, streaming stats) reduce template-writing effort
- Strong security posture: recommends $HF_TOKEN auto-replacement and encrypted secrets, explicitly discourages hardcoded tokens
- Parallel MCP tool, CLI, and Python API equivalents fit different calling styles
- Requires a paid Hugging Face plan; free accounts cannot use Jobs
- The MCP mode's script parameter rejects local paths — a known beginner trap the skill itself flags
- The ephemeral environment makes result persistence the caller's responsibility; forgetting it means total loss
- No test suite or cross-platform validation evidence in the source; cost figures are illustrative guides, actual pricing should be checked with HF
- The repo README describes a 93+ project collection; this skill's quality must be judged independently
How does this skill compare with similar options?
Side by side with related skills; every score comes from the same FSRS standard.
| Skill | FS score | Stars | Last updated | License |
|---|---|---|---|---|
| Hugging Face Jobs Runner Skill this page | 60 · Recommended | ★ 38k | 13d ago | MIT |
| Hugging Face ZeroGPU Builder | 56 · Use with care | ★ 11k | 17d ago | Apache-2.0 |
| HF Model Trainer (TRL on Hugging Face Jobs) | 52 · Use with care | ★ 38k | 13d ago | MIT |
| Clinical ASR Flywheel: Environment Setup ✓ NVIDIA · Official | 54 · Use with care | ★ 3.6k | 11d ago | Apache-2.0 |
| Hugging Face CLI Skill | 55 · Use with care | ★ 38k | 13d ago | MIT |
Compared with the sibling model-trainer skill in the same repo, this is the general-purpose Jobs entry point covering inference, data processing, and scheduling; TRL-specific training workflows are explicitly delegated to model-trainer. If you only need light local compute, the official hf jobs CLI works directly without this skill — its value is giving an AI assistant the correct calling conventions and pitfalls.
How did FollowSkills review this skill?
Positive: thorough token-handling guidance recommending secrets/$HF_TOKEN auto-replacement, repeated warnings against hardcoding tokens or using env for secrets, minimal-permission and rotation advice, clear data-flow disclosure (server-side encrypted secrets, env visible in logs). Deducted: the skill steers the agent into submitting arbitrary scripts to paid cloud compute with no explicit user-confirmation step for cost; weaker explicit-token and env methods remain documented; outbound paths to S3/API exist without sensitive-data redaction guidance; MIT license and attribution asserted at repo level but not independently re-verified in-skill.
Positive: internally consistent docs; MCP/CLI/Python API mappings explicit; the local-path-vs-inline-script pitfall is called out; troubleshooting covers 401/403/timeout/OOM/missing dependencies. Deducted: static review cannot execute anything; no test suite or CI evidence covering key paths; bundled cot-self-instruct.py has a placeholder RIP filter (length used as proxy score); examples assume paid GPU environments; failure feedback quality is only inferable from docs.
Positive: description gives precise trigger conditions (cloud compute, GPU, HF Jobs keywords), clear use/non-use lists, and routes model training to model-trainer skill. Deducted: core function depends entirely on Hugging Face Hub/Jobs and a paid Pro/Team/Enterprise plan, with no declared fallback; no statement on mainland-China network reachability or Chinese-language users; the hard paid-plan requirement narrows the audience.
Positive: SKILL.md plus references (hardware, tokens, saving, troubleshooting) is well layered with progressive disclosure, MIT license metadata present, rich checklists and FAQ-style troubleshooting. Deducted: no version number, no changelog, no stated maintenance ownership or update path; much content derives from official HF docs and the uv-scripts org with limited in-skill attribution; the bundled script claims to implement the paper's RIP method but ships a placeholder, a name-vs-capability mismatch.
Positive: targets real needs (cloud workloads, result persistence, cost estimation), covers common workload types, examples in directly usable form, marginal value over piecemeal doc-reading is clear. Deducted: static review cannot verify examples actually run; cost figures lack a cited official price source and may be stale; the value claim rests on an unverified MCP tool surface.
Positive: substantial auditable primary material (HF docs links, paper citation, reproducible commands, complete scripts); facts and examples separated. Deducted: no tests, no CI, no third-party execution evidence; hardware specs and costs are doc assertions only; claims (vLLM compatibility, flavor list currency) lack cross-source corroboration.
Open a dimension to read why it scored that way
Evidence confidence：Low — Mostly static review, author material or a limited demo; useful for discovery, not high-risk decisions.
See the full review method →