cuTile Python Kernel Assistant
Guides developers in writing, debugging, validating, and optimizing high-performance cuTile GPU kernels.
The skill explicitly instructs agents to write files in the current working directory and to clone TileGym into a cache directory; these external writes, dependency acquisition, and GPU execution effects are disclosed but lack user confirmation, rollback, or least-privilege controls. No credential theft, covert exfiltration, malware, or destructive default is evident, so a moderate score is retained. Attribution and licenses are stated, but repository license metadata is NOASSERTION and the skill instructs generated code to omit source citations, so points are deducted.
The workflow, examples, and validation loop are fairly detailed, but prerequisites, hardware requirements, installation, abnormal-input handling, and diagnosable failure behavior are incomplete. Committed examples and the benchmark provide some auditable evidence, but the benchmark verdict is FAIL and static review cannot resolve possible API or boundary issues. The score remains below the static ceiling of 10.
Invocation scenarios, complexity routing, input parameters, and simple-versus-orchestrated workflows are relatively clear, supporting useful semantic triggering. However, the capability depends heavily on NVIDIA GPUs, CUDA/cuTile, TileGym, and reachable remote documentation or repositories. Chinese-language support and mainland-China network reachability are not addressed, so points are deducted.
The skill provides a name, version, author, licenses, organized references, examples, and workflow guidance. NVSkills-Eval explicitly reports missing Purpose, prerequisites, and limitations; changelog, maintenance ownership, and update path are also not clearly documented. The benchmark additionally reports an overly long description and complex corporate language, preventing a near-full score.
The stated goal is to generate, debug, optimize, and validate cuTile GPU kernels, and the examples include adaptable kernels, launchers, and reference checks. The benchmark reports 86% effectiveness for Codex with the skill, indicating practical value. However, the overall benchmark verdict is FAIL, and static review cannot confirm compilation, boundary correctness, or stable advantage over alternatives, so the score is conservatively capped.
The SKILL.md cites official language documentation, while the repository includes examples, evaluation tasks, and a benchmark report, creating limited auditability. There is no independent reproduction in this static review; the benchmark covers only three tasks and fails overall, while duplicate-content findings indicate maintenance weaknesses. The evidence therefore supports only a limited score, not independent reproducibility.
- Confirm installation and version compatibility for CUDA/cuTile, a compatible NVIDIA GPU, PyTorch, and TileGym before use; complete prerequisites are not documented.
- The workflow writes to the current directory and may clone remote dependencies. Confirm paths, network access, and cache policy, and prepare a manual cleanup or recovery plan.
- Do not treat the documented validation loop as execution evidence for this review; compile and test independently on target hardware, including unaligned shapes and abnormal inputs.
- The benchmark verdict is FAIL and reports missing limitations, missing prerequisites, and substantial duplicate content; revise and rerun evaluation before publication.
What does this skill do, and when should you use it?
This is NVIDIA’s cuTile Python programming skill for tile-based GPU kernel development on NVIDIA hardware. It guides an agent from example and reference lookup through kernel design, implementation, launch, and numerical validation. Single-kernel requests use a stepwise workflow, while multi-kernel or multi-layer model tasks can use deep agent orchestration. It fits developers who need to write GPU compute kernels directly with the cuTile Python DSL.
Searches TileGym and the packaged examples/ directory for relevant patterns, consults the cuTile language specification and guidelines/, analyzes tensor shapes and dtypes, designs tile and grid layouts, generates Python code using constructs such as @ct.kernel, ct.load, ct.store, and ct.launch, and executes the code to compare results with a reference implementation. Complex tasks can be decomposed across an analyzer, parallel kernel agents, and a composer.
- A CUDA/Python developer implementing a cuTile GPU kernel from scratch for ReLU, softmax, matrix multiplication, or another single operation.
- A machine-learning engineer converting PyTorch tensor operations into cuTile implementations.
- A developer diagnosing cuTile compilation, runtime, indexing, typing, or numerical-validation failures.
- An engineer optimizing an existing cuTile kernel for specific tensor shapes, dtypes, or performance targets.
- A developer decomposing a multi-operation model containing attention, feed-forward, normalization, or other dependent kernels.
What are this skill's strengths and limitations?
- Covers cuTile Python kernel authoring, debugging, optimization, and validation.
- Defines concrete rules for example lookup, power-of-two tile dimensions, typed constants, indexing, and boundary handling.
- Separates the workflow for simple single-kernel tasks from complex multi-kernel orchestration.
- Requires execution and comparison against a reference implementation rather than code generation alone.
- Requires cuTile Python, a CUDA-capable NVIDIA GPU, Python, and typically PyTorch for validation.
- The supplied material does not specify a supported GPU architecture matrix, CUDA/cuTile version matrix, or performance guarantee.
- Deep orchestration adds implementation complexity for multi-kernel tasks.
- The supplied material contains the skill instructions but not the referenced example-file contents or implementation code.
How do you install this skill?
Install the specific skill with the skills CLI command documented in the repository README:
npx skills add nvidia/skills --skill tilegym-cutile-python --yes
The supplied README does not document a separate package or version-pinning command for this skill.
How do you use this skill?
After installation, prompt the agent with a concrete request such as: “Write a cuTile ReLU kernel for shape (1024, 1024).” For complex work, provide target shapes, dtypes, performance requirements, and constraints. The skill instructs the agent to search examples first and execute generated code for validation.