# AMD Had Zero Agent Skills. I Built the First 10.

> Source: <https://dev.to/yechuasilva/amd-had-zero-agent-skills-i-built-the-first-10-4mi5>
> Published: 2026-07-10 02:47:28+00:00

NVIDIA has 428+ agent skills on skills.sh. AMD had

zero. This is the story of building the first open-source collection of agent skills for AMD ROCm GPU workloads — and why it matters for the entire AI ecosystem.

If you've used AI coding agents like Claude Code, OpenCode, Cursor, or Codex, you've probably encountered **agent skills** — reusable instruction sets that teach agents how to perform specific tasks. Skills are the building blocks of agent workflows: "set up my GPU", "deploy vLLM", "run YOLO inference", "check PPE compliance".

The agent skills ecosystem is powered by [skills.sh](https://skills.sh), a registry that indexes skill repositories from GitHub. When you run `npx skills add owner/repo`

, the CLI clones the repo and installs skills into your agent's configuration directory.

Here's the problem:

| GPU Vendor | Agent Skills on skills.sh |
|---|---|
| NVIDIA | 428+ |
| AMD | 0 |

Zero. Not a single skill for AMD ROCm. If you're a developer using AMD MI300X, MI250, or even a Radeon RX 7900 with an AI coding agent, you had nothing. Every GPU setup, every Docker configuration, every inference deployment required manual documentation lookup and copy-paste.

I built ** amd-rocm-skills** — 10 production-ready agent skills covering the full AMD ROCm GPU workflow:

| Skill | What it does |
|---|---|
`rocm-setup` |
Install, verify, and configure ROCm on AMD GPUs with PyTorch. Auto-detects NVIDIA CUDA and CPU fallback. |
`rocm-docker` |
Docker with AMD GPU passthrough (`--device=/dev/kfd` ), NVIDIA runtime, and CPU profiles. docker-compose multi-profile. |
`vllm-rocm-deploy` |
Deploy vLLM for LLM/VLM inference on ROCm. InternVL2, Qwen2-VL, LLaVA. OpenAI-compatible API. |
`yolo-rocm-deploy` |
YOLOv8 on PyTorch ROCm. Inference, model export (ONNX, TorchScript), benchmarking. |

| Skill | What it does |
|---|---|
`video-pipeline-rocm` |
Video inference pipeline with GStreamer + ROCm. RTSP capture, hardware decode (AMD VCN / NVIDIA NVDEC), frame extraction, batch inference. |
`vlm-rocm-inference` |
VLM inference directly with PyTorch on ROCm. InternVL2, Qwen2-VL. Multimodal (text + image). |
`rocm-benchmark` |
GPU benchmarking: matmul, memory bandwidth, inference latency, VRAM monitoring. ROCm + CUDA + CPU comparison. |

| Skill | What it does |
|---|---|
`ppe-detection-pipeline` |
PPE (Personal Protective Equipment) detection in video for industrial safety. YOLOv8 + tracking + alerts (webhook, MQTT, log). Multi-camera, multi-GPU. |
`ds132-compliance` |
Chilean DS 132 mining safety compliance checker. Zone-based EPP requirements, audit logging, compliance reports. |
`rocm-troubleshoot` |
Diagnostics and troubleshooting for ROCm. Error codes, compatibility checks, quick fixes, optimization checklist. |

Every skill follows the [agentskills.io](https://agentskills.io/specification) specification — the open standard for agent skills:

```
skills/<skill-name>/
├── SKILL.md          # Required: YAML frontmatter + instructions
├── scripts/          # Required: executable Python/Bash scripts
└── references/       # Optional: technical documentation
```

The `SKILL.md`

frontmatter uses only standard, portable fields:

```
---
name: rocm-setup
description: >
  Install, verify, and configure AMD ROCm on Linux for AI/ML workloads
  with PyTorch. Use this skill when setting up AMD GPUs (MI300X, MI250,
  RX 7900) for GPU-accelerated PyTorch, verifying ROCm installation, or
  diagnosing GPU detection issues. Keywords: rocm, amd, gpu, pytorch,
  hip, setup, mi300x, detect-gpu, rocm-smi, rocminfo, cuda, check-rocm
license: Apache-2.0
compatibility: >
  Compatible with Claude Code, OpenCode, Codex, Cursor, Cline, Roo Code,
  Windsurf, Gemini CLI, and Kiro CLI. Requires Linux with AMD ROCm or
  NVIDIA CUDA GPU (CPU fallback supported).
metadata:
  version: "1.1.0"
  author: yechua-silva
---
```

**No Claude Code-specific fields.** No `context: fork`

, no `agent: Explore`

, no `model: claude-sonnet-*`

. Every skill works identically across 9+ agents.

The key differentiator: **every skill supports three backends with automatic detection**.

``` python
# Auto-detection pattern used across all skills
import torch

if torch.cuda.is_available():
    if torch.version.hip:
        backend = "rocm"        # AMD ROCm
        device = "cuda:0"       # torch.cuda works on both!
    elif torch.version.cuda:
        backend = "cuda"        # NVIDIA CUDA
        device = "cuda:0"
    else:
        backend = "cpu"
        device = "cpu"
```

This is the critical insight: **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.| Component | AMD ROCm | NVIDIA CUDA | CPU |
|---|---|---|---|
| PyTorch |
`torch.cuda` + `torch.version.hip`
|
`torch.cuda` + `torch.version.cuda`
|
`device='cpu'` |
| vLLM | `vllm-openai-rocm` |
`vllm-openai` |
`--device cpu` |
| Docker | `--device /dev/kfd --device /dev/dri` |
`--gpus all` |
No flags |
| Video decode | VAAPI / VCN | NVDEC | avdec (software) |

The `rocm-docker`

skill includes a `docker-compose.yml`

with three profiles:

```
# AMD ROCm
docker compose --profile rocm up -d

# NVIDIA CUDA
docker compose --profile nvidia up -d

# CPU fallback
docker compose --profile cpu up -d
```

| Agent | Supported | How |
|---|---|---|
| Claude Code | ✅ | `.claude/skills/` |
| OpenCode | ✅ | `.agents/skills/` |
| Codex | ✅ | `.codex/skills/` |
| Cursor | ✅ | `.cursor/skills/` |
| Cline | ✅ | `.cline/skills/` |
| Roo Code | ✅ | `.roo/skills/` |
| Windsurf | ✅ | `.windsurf/skills/` |
| Gemini CLI | ✅ | `.gemini/skills/` |
| Kiro CLI | ✅ | `.kiro/skills/` |

```
# List available skills
npx skills add yechua-silva/amd-rocm-skills --list

# Install a single skill
npx skills add yechua-silva/amd-rocm-skills --skill rocm-setup --agent opencode --yes

# Install all skills in multiple agents
npx skills add yechua-silva/amd-rocm-skills -a claude-code -a opencode -a cursor --yes
```

After installing the `rocm-setup`

skill, just tell your agent:

"Set up this AMD server for GPU workloads"

The agent will:

`detect-gpu.py`

to identify your backend (ROCm, CUDA, or CPU)`check-rocm.sh`

for a full health check`HIP_VISIBLE_DEVICES`

, `ROCm_PATH`

)After installing `ppe-detection-pipeline`

:

"Detect PPE in this RTSP stream and alert when workers are missing helmets"

The agent will:

The `detect-gpu.py`

script (from `rocm-setup`

) is the foundation of all 10 skills. It detects the GPU backend in three levels:

``` python
# Level 1: PyTorch
import torch
if torch.cuda.is_available():
    if hasattr(torch.version, 'hip') and torch.version.hip:
        backend = "ROCM"
        device_name = torch.cuda.get_device_name(0)
        # e.g., "AMD Instinct MI300X"
    elif torch.version.cuda:
        backend = "CUDA"
        device_name = torch.cuda.get_device_name(0)
        # e.g., "NVIDIA A100-SXM-80GB"

# Level 2: System commands
import subprocess
if backend == "unknown":
    try:
        result = subprocess.run(["rocm-smi", "--showproductname"],
                                capture_output=True, text=True)
        if result.returncode == 0:
            backend = "ROCM"
    except FileNotFoundError:
        pass

    try:
        result = subprocess.run(["nvidia-smi", "--query-gpu=name",
                                "--format=csv,noheader"],
                                capture_output=True, text=True)
        if result.returncode == 0:
            backend = "CUDA"
    except FileNotFoundError:
        pass

# Level 3: CPU fallback
if backend == "unknown":
    backend = "CPU"
```

This three-level detection ensures every skill works on any machine — whether you have an MI300X with 192GB HBM3, an RTX 4090, or just a laptop CPU.

This isn't just a collection of scripts. It's built to industry standards:

`npx skills add`

`skills.sh.json`

Before any skill is merged:

`name`

field matches directory name (kebab-case)`description`

includes keywords for agent matching`description`

includes trigger phrases ("Use when...")`compatibility`

is a string, not a YAML list`context`

, `agent`

, `model`

, `hooks`

)`chmod +x`

)`## Related Skills`

section| 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 |
| References to specific projects | 0 (fully agnostic) |

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. AMD's MI300X is a phenomenal chip (192GB HBM3, competitive with H100 for many workloads), but the developer experience gap is real.

Agent skills are the newest frontier of this gap. When a developer asks Claude Code to "set up my AMD GPU for PyTorch", the agent should know how. Without a skill, it hallucinates or gives generic advice. With a skill, it follows a tested, verified workflow.

**10 skills won't close a 428-skill gap.** But it's a start — and it's open source.

Want to add a skill? Here's how:

`skills/your-skill-name/SKILL.md`

with frontmatter`scripts/`

with executable Python/Bash`references/`

with technical docsSee [CONTRIBUTING.md](https://github.com/yechua-silva/amd-rocm-skills/blob/main/CONTRIBUTING.md) for the full guide.

`rocm-tuning`

— ROCm performance tuning (HIPBLAS, RCCL, MIOpen)`onnx-rocm`

— ONNX Runtime with ROCm execution provider`fsdp-rocm`

— Fully Sharded Data Parallel on AMD GPU`triton-rocm`

— Triton kernels on ROCm`composable-kernel`

— AMD CK for custom kernels

```
npx skills add yechua-silva/amd-rocm-skills --list
```

**Repo:** [github.com/yechua-silva/amd-rocm-skills](https://github.com/yechua-silva/amd-rocm-skills)

**License:** Apache 2.0

*Built during AMD Developer Hackathon Act II — Pista Unicornio. If you're using AMD GPUs with AI agents, I'd love to hear your feedback.*