AMD ROCm Skills Were Zero on skills.sh. NVIDIA Had 428

NVIDIA has 428+ agent skills listed on skills.sh. AMD's ROCm platform, by the same count, had zero. That gap — tallied by a developer building AI-agent tooling on AMD hardware — is the starting point for the first open-source skill pack written specifically for ROCm GPUs.

The developer's own framing, laid out in the project's repository, is blunt: "If you're a developer using AMD MI300X, MI250, or even a Radeon RX 7900 with an AI coding agent, you had nothing." The question this raises for infra teams running ROCm today is simple — does ten new skills actually close that gap, or just mark where it starts?

What an "agent skill" is, and why the count matters

Agent skills are packaged instructions — setup steps, verified commands, decision trees — that tools like Claude Code, Cursor, or Codex load before acting on a task. Without one, the author argues, "every GPU setup, every Docker configuration, every inference deployment required manual documentation lookup and copy-paste." With one, an agent follows a tested path instead of guessing.

That is why a registry count like skills.sh matters more than it sounds: a listed skill is one less time an agent has to hallucinate a --device=/dev/kfd flag or improvise a PyTorch install command from memory. NVIDIA's 428+ listings mean CUDA users already have that safety net for most common tasks. AMD users, per this count, did not.

What one developer built to close it

The response is a repository called amd-rocm-skills. The author describes it as "10 production-ready agent skills covering the full AMD ROCm GPU workflow," organized into groups — starting with a "Core (4 skills)" set.

One of those core skills is rocm-setup. Per the source: "Install, verify, and configure ROCm on AMD GPUs with PyTorch. Auto-detects NVIDIA CUDA and CPU fallback."

Another, rocm-docker, handles "Docker with AMD GPU passthrough (--device=/dev/kfd), NVIDIA runtime, and CPU profiles," across a multi-profile docker-compose setup.

Further along the set, an applied example like ppe-detection-pipeline shows the pattern extending past setup and into inference: asked to "detect PPE in this RTSP stream and alert when workers are missing helmets," the skill has the agent auto-detect the GPU backend, load a YOLOv8 model, and track people across frames. These three are examples from the ten-skill set, not a full list.

The author also publishes stats for the collection as a whole — self-reported, not independently verified here:

Metric	Value
Skills	10
Total lines of content	~32,000
Scripts (Python + Bash)	26
Reference documents	23
Compatible agents	9+
GPU backends	3 (ROCm + CUDA + CPU)
License	Apache 2.0

The comparison the author leads with is this one, and it is worth seeing in full:

GPU vendor	Agent skills on skills.sh
NVIDIA	428+
AMD, before this project	0
AMD, after this project	10

The multi-GPU trick under the hood

The design choice that makes all ten skills portable is not AMD-specific at all. As the author puts it: "PyTorch's torch.cuda API works on both AMD ROCm and NVIDIA CUDA. There is no torch.rocm. ROCm uses the standard torch.cuda namespace transparently. Use torch.version.hip to distinguish AMD from NVIDIA." Every skill checks for that attribute instead of assuming a vendor, then falls back to CUDA or CPU depending on what's available, so "every skill works on any machine, whether you have an MI300X with 192GB HBM3, an RTX 4090, or just a laptop CPU."

The pattern, translated into illustrative code (not the project's literal source), looks like this:

// Illustrative example of the detection logic described in the source
import torch

if torch.cuda.is_available():
    if getattr(torch.version, "hip", None):
        backend = "rocm"   # AMD GPU via ROCm
    else:
        backend = "cuda"   # NVIDIA GPU via CUDA
else:
    backend = "cpu"        # no GPU found

The author also notes the skills carry "no Claude Code-specific fields. No context: fork, no agent: Explore, no model: claude-sonnet-*," and claims each one "works identically across 9+ agents" — a portability claim worth testing yourself rather than taking at face value, since it comes from the project's own documentation rather than third-party benchmarking.

Why the gap exists, according to the person who filled part of it

The author's read on the underlying cause is an opinion, not a measured fact, and is worth treating that way: "The AI ecosystem has a GPU diversity problem. NVIDIA dominates not just hardware, but the entire software tooling stack — documentation, tutorials, community, and now agent skills." He calls AMD's flagship chip "a phenomenal chip (192GB HBM3, competitive with H100 for many workloads)," while arguing "the developer experience gap is real. Agent skills are the newest frontier of this gap."

That framing lines up with a pattern infra teams already know from bare-metal ROCm work: the hardware argument and the tooling argument are separate arguments, and closing one doesn't automatically close the other. Ten skills, however well built, are a rounding error against 428 — the author says as much: "10 skills won't close a 428-skill gap. But it's a start — and it's open source."

One caveat worth stating plainly: this account draws on a single write-up and its own repository. There is no independent report yet confirming the 9+ agent compatibility claim or the 428 count from a second source, so treat this as an early, single-source account of the project rather than a verified industry survey.

Should you install it?

If your team already runs MI300X, MI250, or Radeon-class GPUs behind an AI coding agent, installing the pack costs little and removes a specific failure mode: an agent improvising Docker flags or PyTorch install steps instead of following a checked path. Treat the "works across 9+ agents" and "~32,000 lines" figures as the author's own count until you have run it against your own stack.

If your infrastructure is NVIDIA-only, there is still something to take from this: the torch.version.hip fallback pattern is a template for writing any GPU-facing skill so it degrades to CPU instead of failing outright — useful even if ROCm never enters your stack.

The repository is Apache 2.0 and, per the author, was "built during AMD Developer Hackathon Act II — Pista Unicornio," with an open invitation for feedback from anyone running AMD GPUs with AI agents. Whether ten skills turn into fifty is now a question of whether other ROCm users show up to extend it — not one this developer can answer alone.