[Skill proposal] <optimizing-models-with-quark: install Quark's model optimization skills on demand>

[amd-zhaofeng]

Proposed skill name

optimizing-models-with-quark

Does something like this already exist?

Yes — as a similar skill in another catalog or repo

Is AMD the only credible institution to create this skill?

Yes

Where should this skill live?

Path A: incubated in this repo (may move to a product repo and continbue to be registered here)

Catalog focus area

Other / not sure

Skill description

Background

AMD Quark (amd/Quark, pip install amd-quark) is AMD's model optimizer: it takes a trained PyTorch or ONNX model and produces a smaller, faster version for AMD hardware through quantization (FP8, INT8, INT4, MX formats), pruning and quantization-aware training.

The catalog has no model optimization skill today. When a user says "quantize this model to FP8", there is nothing to offer. amd-skill-finder (#119) already routes quantization questions to amd/Quark correctly, but all it can return is a repository address — the agent still has to read the docs and guess the flags. Meanwhile Quark already ships skills of its own, and users of this catalog cannot reach them.

We propose Path A, authoring the skill in this repo. It is one entry point, and the Quark skill bodies are delivered through pip rather than vendored, so there is no copy in the catalog that can go stale.

What the skill does

optimizing-models-with-quark is an entry-point skill. It optimizes nothing itself; it connects the user to Quark's own skills.

1. Recognize — establish that this is a model optimization task and that Quark is the right tool.
2. Install — with the user's consent, run pip install amd-quark, then tell agent where to find skills in amd-quark (https://github.com/amd/Quark/tree/release/0.12/.claude/skills)
3. Hand off — tell the user to restart the agent. After a restart the skills are discovered normally and routing is handled by the framework. If the user wants to continue right away, the entry-point skill can read the matching file directly (.claude/skills/quark-torch-ptq/SKILL.md, for example) and carry on. That is a one-off fallback: it puts the file contents in context but does not activate the skill, so a later question still will not route to a Quark skill on its own.

The catalog maintains this single entry point. The skill bodies are delivered through pip, so there is no vendored copy that can go stale.

Note: As of amd-quark v0.12, the skills ship in the repository's .claude/ directory. In v0.13 they will be reorganized into the quark package itself, installable via pip. This skill will be updated incrementally once amd-quark v0.13 is released.

[amd-zhaofeng]

Implementation note: interim approach for amd-quark v0.12

The note above records that the skills currently sit in the repository's .claude/ directory and move into the quark package in amd-quark v0.13. While scoping the implementation we found that the constraint is not only about where they live: the delivery mechanism described above does not hold on v0.12 at all. Recording the actual situation and the resulting interim design here, so it is not mistaken for the intended one.

Why an interim approach is needed

Three constraints, all of which v0.13 is expected to remove:

1. The pip package does not carry the skills. pip install amd-quark installs the optimizer library only. The skills live in the Quark repository, not in the distributed package, so "install the package, then point the agent at its skills" is not yet a path that works.
2. A skill is not a single self-contained file. Each skill is a thin routing entry that defers to a separate implementation layer in the repository. Fetching only the entry points yields skills that cannot execute.
3. Files in that implementation layer reference each other by relative path, and a single quantization run traverses several of them. So the two parts have to travel together as a complete tree; fetching individual files on demand is not reliable.

What the entry-point skill does in the interim

The intent of the proposal is unchanged: one entry point in this catalog, no vendored copy of Quark's skills that can go stale. What changes is that v0.12 does not install Quark's skills as skills at all. They are retrieved as a local document tree and read as files. In short: the library still arrives through pip; only its skills change delivery, from installed skills to files the agent reads.

• Recognize the task as model optimization and confirm Quark is the right tool. Unchanged.
• Retrieve the tree from the Quark repository with the user's consent, into a cache directory outside the user's workspace. Nothing is copied into this catalog and nothing is written into the user's repository or into any agent's skills directory.
• Defer environment setup. The library is still installed the usual way with pip install amd-quark — that part does not change. What changes is who drives it: Quark already ships its own environment-preflight and installation skills, and one of the exposed starting points leads there, so the entry point does not run the install itself. Duplicating that logic here would drift from upstream.
• Read, don't install. The entry point names the file the agent should start from and lets it follow the references from there. No agent restart is required — the user continues in the same session.

The trade-off is worth stating plainly. Because nothing is registered as a skill, a later question will not route to a Quark skill on its own; every request goes through this entry point. That is the same caveat the proposal already described for its one-off fallback, except that in v0.12 it is the only mode rather than the exception. In exchange we avoid installing anything into the user's workspace and avoid the restart, and there is nothing to clean up when v0.13 lands.

Scope for the first version

The entry point exposes three starting points rather than Quark's full skill set: PyTorch PTQ, ONNX PTQ, and Quark environment setup. These cover the requests the catalog actually receives today. The retrieved tree remains complete, because the two PTQ flows depend on upstream steps that are not themselves exposed; the entry point simply tells the agent to keep following references within the tree.

What v0.13 should simplify

Once the skills ship inside the quark package, retrieval goes away and the entry point can become what the proposal originally described: confirm the package is present, point the agent at the skills it already contains, hand off — at that point as real skills, with framework routing. We will update this skill incrementally as v0.13 lands rather than waiting for a single rewrite.