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

wpnews.pro

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, 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 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.

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:

docker compose --profile rocm up -d

docker compose --profile nvidia up -d

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/`

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

npx skills add yechua-silva/amd-rocm-skills --skill rocm-setup --agent opencode --yes

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 checkHIP_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:

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)
    elif torch.version.cuda:
        backend = "CUDA"
        device_name = torch.cuda.get_device_name(0)

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

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 matchingdescription

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

is a string, not a YAML listcontext

, 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 frontmatterscripts/

with executable Python/Bashreferences/

with technical docsSee CONTRIBUTING.md for the full guide.

rocm-tuning

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

— ONNX Runtime with ROCm execution providerfsdp-rocm

— Fully Sharded Data Parallel on AMD GPUtriton-rocm

— Triton kernels on ROCmcomposable-kernel

— AMD CK for custom kernels

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

Repo: 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.

source & further reading

dev.to — original article Stratagems #10: Lena Watched a Team Adopt Her AI Template. Leo Didn't Know the Knife Was in the Contract. Testing Face Embedding Nearest Neighbor Search with OpenCV SFace Building Zero-Dependency MCP Servers in Pure Python

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

Run your AI side-project on zahid.host