Hugging Face Jobs Runner Skill
Lets your AI assistant submit any Python workload to Hugging Face's fully managed cloud compute — no local GPU or setup — while safely handling auth, timeouts, and result persistence.
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.
- 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.
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
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 do you install this skill?
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.
How do you use this skill?
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.
How does this skill compare with similar options?
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.