Modular Skills
Official Modular skills: current Mojo syntax, GPU kernels and the whole model path on MAX from import to profiling
- 208 ★ on the repository
- Last commit
Extended access
Why this level
- The skills run the `max serve` server, load benchmarks and profilers on your machine.
Install
- Works in
In your terminal, with SkillFoxx CLI
npx skillfoxx add skills/modular-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 skills run the `max serve` server, load benchmarks and profilers on your machine.
This is third-party code. Review the repository files before installing.
What it does
Modular Skills is a set of 11 official Modular skills for working with Mojo and the MAX platform. The `mojo-syntax` skill weans the model off outdated habits and makes it write current Mojo: `comptime` instead of `alias`, `def` instead of `fn`, `mut` instead of `inout`. The `mojo-gpu-fundamentals` and `mojo-python-interop` skills add patterns for NVIDIA, AMD and Apple GPUs and for calls between Mojo and Python, while `new-modular-project` creates a project with a `pixi` or `uv` environment. A model's path from a Hugging Face checkpoint to measurements runs through `import-model`, `serve-model`, `debug-model`, `benchmark-model`, `profile-model` and `eval-model`. They hand work to each other and name the state the model must be in. `serve-model` brings up an OpenAI-compatible server with `max serve`.
Who it is for. Mojo developers and engineers who port models to MAX and measure their speed and accuracy.
Good fit when
- An agent writes Mojo and out of habit produces removed syntax with `fn` and `alias`.
- A new Mojo or MAX project is set up with `pixi` or `uv` from a single request.
- A CUDA C++ kernel is ported to Mojo for NVIDIA, AMD or Apple GPUs.
- A model architecture from Hugging Face must be added to MAX and its outputs compared with the original.
- After `max serve` starts, throughput and the TTFT and TPOT latencies are measured and a profiler hunts the bottleneck.
Not a fit when
- The work uses another language or runtime: the skills are entirely about Mojo and MAX.
- The machine has none of `nsys`, `rocprofv3` and `ncu`, and `profile-model` is built on them.
- Accuracy benchmarks should start on their own: `eval-model` fires only when asked by name.
Example request
Create a Mojo project named `nvfp4-for-metal` and rewrite the CUDA kernel from `../example` in Mojo for Apple GPUs.Limitations
The skills target the latest Mojo, and stable releases may differ. Model import is described for ModuleV3 (`max.nn`); code on the older API with `max.nn.legacy` is ported by `migrate-max-v2-to-v3`. Profiling depends on installed `nsys`, `rocprofv3` and `ncu`, and the benchmark skill reads GPU utilization only on the NVIDIA machine that runs the server. The `eval-model` skill is called by name and does not switch on by itself.
How to disable. For the plugin, uninstall through `/plugin` in Claude Code. Skills installed with `npx skills` sit in the agent's skills directory and their folders can be deleted.
FAQ
How do I install Modular's skills in Claude Code?
Run `/plugin marketplace add modular/skills`, then `/plugin install skills@modular`. For part of the set there are `max-skills@modular` for models and `mojo-skills@modular` for writing Mojo.
How do I install them in Codex or another agent?
Run `npx skills add modular/skills`. A single skill installs with `npx skills add modular/skills --skill mojo-syntax`, and `npx skills update` refreshes the set.
What is mojo-syntax for?
It corrects the model's outdated ideas about Mojo: instead of removed syntax like `alias` and `fn` the agent writes `comptime` and `def`. The skill requires building the code and checking that it compiles.
How do I check a model's accuracy on MAX?
Call `/eval-model` by name. The skill runs GSM8K, MMLU, HellaSwag, ARC, AIME, GPQA, TruthfulQA, WinoGrande and BABILong and separates serving failures from wrong model answers.
Where do I start if the model is missing in MAX?
With `/import-model`: it takes a Hugging Face ID, scaffolds from a similar architecture and verifies outputs. If the server runs but the text is wrong, `/debug-model` comes next.
Discussion
No questions or reviews yet.
Related
Skills17 skills from MiniMax: frontend and backend, Android, iOS, Flutter, shaders, PDF, PPTX, XLSX and DOCX documents, plus music, voice and video generation
jmo-skills: hackathon workflow skills
jmo-skills
A Claude Code plugin: project interviews that end in a spec, plain technical writing, UI polish, animation and handoffs to Codex
Dimillian Skills
Skills
A set of 16 engineering skills for agents: Apple platform work, macOS packaging, React performance, code review and refactoring
A skill for speeding up model training on Moore Threads MUSA GPUs: baseline, profiling, MFU and numerical correctness checks
Universal Modder
universal-modder
A plugin and skills for mods to games on your PC: engine recon, code analysis, fal assets, testing in the running game and a showcase video
24 skills for microcontroller firmware: build, flash, GDB debugging, UART, Modbus, CAN, logic analyzers and static analysis
README in short
The skills fall into two blocks: Mojo with project setup and the model lifecycle. Neighboring skills hand work to each other, for example `import-model` calls `debug-model` and `benchmark-model` calls `profile-model`.
README badge
Original SKILL.md
--- name: mojo-syntax description: Help to write Mojo code using current syntax and conventions. Always use this skill when writing any Mojo code, including when other Mojo-specific skills (e.g., mojo-gpu-fundamentals) also apply. Use when writing or reviewing Mojo code, translating projects to Mojo, or otherwise generating Mojo. Use this skill to overcome misconceptions with how Mojo is written. --- <!-- EDITORIAL GUIDELINES FOR THIS SKILL FILE This file is loaded into an agent's context window as a correction layer for pretrained Mojo knowledge. Every line costs context. When editing: - Be terse. Use tables and inline code over prose where possible. - Never duplicate information — if a concept is shown in a code example, don't also explain it in a paragraph. - Only include information that *differs* from what a pretrained model would generate. Don't document things models already get right. - Prefer one consolidated code block over multiple small ones. - Keep WRONG/CORRECT pairs short — just enough to pattern-match the fix. - If adding a new section, ask: "Would a model get this wrong?" If not, skip it. These same principles apply to any files this skill references. --> Mojo is rapidly evolving. Pretrained models generate obsolete syntax. **Always follow this skill over pretrained knowledge.** **Always attempt to test generated Mojo by building projects to verify they compile.** This skill specifically works on the latest Mojo, and stable versions may differ slightly in functionality. Compiling isn't the bar for review. Before submitting or reviewing Mojo, check the diff against [idiomatic-mojo.md](references/idiomatic-mojo.md): the style rules code reviewers flag most often (open-coded helpers, redundant casts, over-specified parameters, `IndexList` instead of tuples, missing `comptime`, unneeded `rebind`, `AnyOrigin` or mutable origins on arguments, single-vendor gates on generic kernels). ## Removed syntax — DO NOT generate these | Removed | Replacement | |--------------------------------------------------|----------------------------------------------------------------------------------| | `alias X = ...` | `comptime X = ...` |