GPU Development Skills
Skills for writing, debugging, measuring and optimizing TileLang and CUDA programs from source, lowering and profiler evidence
- 149 ★ on the repository
- Last commit
Extended access
Why this level
- The installer runs from a script by link, creates an environment and installs Python packages
- The skills run compilation, profilers and benchmarks on your GPU
Install
- Works in
In your terminal, with SkillFoxx CLI
npx skillfoxx add skills/gpu-development-skillsDetects the agents on your machine, shows the access level and pins the version.
Other ways to install
Access and checks
How we reviewExtended accessThe tool runs code or makes network calls and only reads external data.
- The installer runs from a script by link, creates an environment and installs Python packages
- The skills run compilation, profilers and benchmarks on your GPU
This is third-party code. Review the repository files before installing.
What it does
GPU Development Skills is an agent skill suite for TileLang and CUDA work. Start with the tilelang-optimization-loop skill: it runs an iterative task through a contract, draft, executable plan, candidate, validation, measurement and promotion cycle. The cycle is adapted from KDA (kernel-design-agents) to TileLang lowering. The agent analyzes the supplied PyTorch baseline through torch.compile graphs and profiling, then connects each candidate's intended mechanism to its emitted implementation and measured result. The plan and candidate history live in the task workspace. Specialists are also called individually: writing-tilelang-kernels (PrimFunc factories, eager JIT, tensor contracts), writing-tilelang-design-docs (proposals and reports with data-flow visuals), debugging-tilelang-programs, profiling-tilelang-programs, torch-profiling-tilelang-programs, optimizing-tilelang-programs (measured experiments, autotuning, layout) and testing-fwd-bwd-kernels (autograd contracts and independent gradient checks). A separate cuda_skill covers compilation, launch contracts, sanitizers, Nsight and NVTX. The optional designing-with-tilefoundry skill adds authored HIR, static analysis and a graph viewer.
Who it is for. Engineers who write and optimize GPU kernels in TileLang and CUDA and want an agent to work from measurements.
Good fit when
- A PyTorch baseline has to become a TileLang kernel confirmed by measurements
- A TileLang program fails and needs analysis from lowering traces and buffers
- A training operation needs its forward and backward passes and all gradients validated
- CUDA code must be built with sanitizers and profiled with Nsight
Not a fit when
- There is no NVIDIA GPU and CUDA: many steps rely on measurements and profilers on the device
- You need a quick edit without an experiment cycle: the suite is built for iterative work
- You need a ready kernel library: the skills teach how to write kernels and contain no library
Example request
Use tilelang-optimization-loop: analyze my PyTorch attention implementation, write a TileLang kernel, validate against the reference and show measurements before and afterLimitations
Python 3.12 or newer is required, and installation creates a <suite>/.venv virtual environment. The installer adds pinned TileFoundry packages (core, NVIDIA and Apple, CUTLASS sources, cmake and ninja) and verifies KernelWiki. Workflows were reviewed against TileLang 0.1.14 and 0.1.15, PyTorch 2.13 and CUDA 13.0, so on other versions check the active one and do not trust copied snippets. Installation runs through curl and a script that is worth reading before running.
How to disable. Remove the skill symlinks from ~/.agents/skills, ~/.claude/skills and ~/.codex/skills, then the ~/.local/share/tilelang-cuda-skills cache and the suite virtual environment.
FAQ
Where should I start with the suite?
With the tilelang-optimization-loop skill for an iterative task: it leads from a contract and draft through validation to measurement and promotion of a candidate. For a focused question call a specialist directly.
How do I install the skills?
With curl -fsSL https://raw.githubusercontent.com/sablin39/tilelang-cuda-skills/main/scripts/install-skills.sh | bash -s -- --scope global. From a clone use ./scripts/install-skills.sh --scope global --target all, and --scope project for a project. --check-only audits without changing anything.
What is KernelWiki in this suite?
A separate skill with implementation and hardware research that the installer sets up next to the others and verifies with the scripts/query.py smoke test. TileLang skills tie its explanations to lowering and measurements.
How are training kernels validated?
Joint forward and backward mode keeps kernels and saved state aligned, validates all gradients and picks the pair by a complete forward-plus-backward measurement. It is described in references/joint-fwd-bwd.md.
Is TileFoundry required?
It is optional for the TileLang skills, but the installer adds pinned TileFoundry packages for the designing-with-tilefoundry skill. Use that skill when decisions span fusion, sharding or memory-placement boundaries.
Discussion
No questions or reviews yet.
Related
SkillsA Claude Code skill for GPU kernel tuning: the agent profiles, edits and benchmarks a kernel in a loop until speedup stalls.
Claude Code skill reading Nsight Compute reports on Blackwell: from a CUDA kernel profile to a diagnosis and an optimization plan.
The official catalog of NVIDIA agent skills: CUDA, accelerated libraries, RAG, robotics and simulation through coding agents
ForgeKernel is a CLI that tunes a GPU kernel for hours: Claude Code writes variants, timing and profiling drop slower ones.
A skill that pulls live Tensorlake documentation so agents write sandbox code against real SDK signatures.
Over 140 skills for systems programming: compilers, debuggers, profilers, firmware, the Linux kernel and binary analysis.
Comparison with similar tools
Cards that share the main search query, and how they differ.
| Tool | Official | Repository stars | Main difference |
|---|---|---|---|
| GPU Development Skills (this card) | no | 149 | |
| KernelWiki | no | 547 | the implementation and hardware knowledge base that the suite plugs in |
| Triton-Ascend Agent Development Kit | no | 189 | Triton kernel development for Ascend |
README in short
The README starts with the suite description and a recommendation to begin from tilelang-optimization-loop, then covers installation (quick, from a clone, per project, with an existing environment), and KernelWiki and TileFoundry setup. A table of TileLang skills, extra Python dependencies, the CUDA skill and stage handovers and maintenance follow.
README badge
Original SKILL.md
--- name: tilelang-optimization-loop description: Run a bounded TileLang implementation and optimization task from a PyTorch reference or existing kernel through baseline analysis, a written plan, candidate edits, lowering inspection, validation, measurement, and promotion. Use for iterative kernel work and reproducible handoffs; use a specialist directly for a single API, debugging, or profiling question. --- # TileLang Optimization Loop Follow a repeatable experiment cycle in the **task workspace**. Keep the skill suite and its upstream knowledge separate from generated kernels and results. Resume from evidence that still matches the source, inputs, and environment. This adapts the [KDA workflow](https://github.com/mit-han-lab/kernel-design-agents/blob/4806866492d5c7cad05e07918790bd1e94e976a1/docs/agent-flow.md) to the chain from TileLang source through compiler lowering to GPU behavior. ## Route by the current decision At each stage, name the question, read the selected specialist's entrypoint, and consume its finding in the next decision. A link alone is not a completed specialist step. Reuse matching evidence rather than rereading or rerunning everything. Use the [stage report](references/stage-handoff.md) for iterative tasks and session/worker handoffs; link it from the existing candidate ledger. | Current question | Skill to read | | --- | --- | | What does the PyTorch baseline execute and allocate? | [Torch profiling](../tilelang/torch-profiling-tilelang-programs/SKILL.md) | | Which hardware mechanism or instruction contract informs this choice? | [KernelWiki interface](references/kernelwiki.md), then the installed KernelWiki skill | | Does a high-level placement or fusion choice need a semantic/static model? | [TileFoundry design](../designing-with-tilefoundry/SKILL.md) | | How should this candidate express the operation? | [Writing kernels](../tilelang/writing-tilelang-kernels/SKILL.md) | | Why is output wrong, or why did the intended lowering disappear? | [Debugging](../tilelang/debugging-tilelang-programs/SKILL.md) | | Are the gradients and saved-state contract correct? | [Forward/backward testing](../tilelang/testing-fwd-bwd-kernels/SKILL.md) | | Is the comparison reliable, and what does the profile show? | [Profiling](../tilelang/profiling-tilelang-programs/SKILL.md) | | Which bounded schedule change tests that finding? | [Optimization](../tilelang/optimizing-tilelang-programs/SKILL.md) | | How should the supported design be explained? | [Design documents](../tilelang/writing-tilelang-design-docs/SKILL.md) | Mark a route unused when it does not answer the current question. Record an unavailable specialist/tool and the resulting evidence gap; do not substitute a prose guess for its check. Native CUDA compilation or sanitizer work can use the [CUDA workflow](../cuda_skill/SKILL.md) when that boundary is relevant. ## 1. Establish the contract and baseline Read the reference, current candidate, caller, and harness. Record the following in the existing task record, or in `docs/draft.md`: - Operation and input/output structure, shapes, dtypes, strides, accuracy, mutation/aliasing, initialization, stream, and gradient requirements.