Create a skill with SKILL.md — Mistral Vibe Advanced: Agents, Skills, and Local Mode

Lesson updated November 2, 2026 based on the Skills page in the Vibe documentation: a skill is a set of instructions (it does not add tools), allowed-tools is read but not enforced, and two fields have been added (disable-model-invocation, compatibility). Source: Skills.

Skills: Reusable components

Agents define who executes a task. Skills define what: they are reusable instruction sets that add procedures and slash commands to Mistral Vibe. The distinction becomes concrete when you apply it to your team—an agent reflects a personal working posture, while a skill encapsulates a procedure that everyone must execute in the same way.

A skill is a directory containing a SKILL.md file with a YAML frontmatter. This structure follows the open Agent Skills specification, making skills portable and shareable: the same folder works on your colleague’s machine without adaptation.

Anatomy of a SKILL.md

Here is the complete structure of a skill, illustrated by an automated code review example:

---
name: code-review
description: Performs automated code reviews with quality analysis
license: MIT
user-invocable: true
allowed-tools:
  - read_file
  - grep
  - ask_user_question
---

# Code Review Skill

This skill analyzes source code quality by checking:

1. **Naming conventions** — variables, functions, classes
2. **Cyclomatic complexity** — functions that are too long or nested
3. **Duplication** — copy-pasted code to refactor
4. **Security** — dangerous patterns (eval, SQL injection, XSS)

## Usage

Run `/code-review` followed by the path or description of the code to analyze.

## Output format

The report is structured in three levels:
- 🔴 **Critical** — fix immediately
- 🟡 **Warning** — fix before merging
- 🟢 **Suggestion** — optional improvement

The YAML frontmatter fields

The name field is the unique identifier for the skill. It is used to enable, disable, and reference the skill in configurations. This name also becomes the slash command, so it is worth keeping it short.

name: code-review

The description, up to 1,024 characters, is the phrase that appears when Vibe lists available skills. Write it from the perspective of someone searching: it should allow them to choose between two similar skills without opening the files.

description: Performs automated code reviews with quality analysis

The license field indicates the skill’s license, which becomes important as soon as you share it beyond your own workstation.

license: MIT

The boolean user-invocable, true by default, exposes the skill as a slash command. Set it to false to hide it from the / menu: the agent can still load it automatically when the task fits.

user-invocable: true   # Accessible via /code-review
user-invocable: false  # Hidden from / menu, agent can still load it

The disable-model-invocation field, when set to true, prevents the agent from loading the skill on its own: it only runs if you type /skill-name. Reserve this for procedures that no model should trigger without your explicit consent, such as a deployment.

disable-model-invocation: true

Two informational fields complete the list: compatibility, which notes prerequisites (“Requires git”), and allowed-tools, which lists the tools the skill intends to use. Be careful with the latter: the documentation specifies that Vibe reads it but does not enforce it. A skill can call any tool that the active agent authorizes. To limit what a skill can do, restrict the tools and permissions of the agent (Lessons 2 and 3).

allowed-tools:
  - read_file
  - grep
  - ask_user_question

The body of SKILL.md

After the frontmatter, the body of the file is free-form Markdown. It serves as both documentation and prompt: Vibe reads it to understand how the skill works and in what context to apply it. This is where you describe what the skill does, the steps of its operation, the expected output format, and usage examples. A vague body yields an unpredictable skill; a precise body yields a skill that produces the same result week after week.

Create your first skill

Let’s build a test generation skill. Start by creating its directory:

mkdir -p ~/.vibe/skills/test-generator

Place the following SKILL.md inside. Notice how the body answers questions Vibe would otherwise have to guess: which framework to choose, how to name blocks, where to write the output file.

---
name: test-generator
description: Generates unit tests for TypeScript/JavaScript functions
license: MIT
user-invocable: true
allowed-tools:
  - read_file
  - write_file
  - grep
---

# Test Generator

Generates comprehensive unit tests for
TypeScript and JavaScript functions.

## Process

1. Read the target source file
2. Identify all exported functions
3. For each function, generate:
   - Happy path test
   - Test with empty/null inputs
   - Edge case tests
   - Expected error tests
4. Write tests to an adjacent `.test.ts` file

## Conventions

- Framework: Vitest (default) or Jest if detected
- Naming: `describe` per function, `it` per test case
- Assertions: `expect` with precise matchers
- No mocks unless necessary (external dependencies)

## Example

For a file `utils/math.ts` containing `add(a, b)`,
the skill generates `utils/math.test.ts` with corresponding tests.

Once the file is created, the skill is immediately available: no installation command, no restart. Launch Vibe and call it on a real file.

vibe
# > /test-generator src/utils/math.ts

Vibe loads the skill, reads its SKILL.md to understand the expected behavior, and executes the task with the authorized tools. Take the time to read the result: by comparing the output to what you imagined, you will refine the file body.

Best practices

Stick to one skill per feature. Mixing code review and test generation in a single file produces a prompt that hedges, and prevents you from disabling one without losing the other. Similarly, limit authorized tools to those the skill actually needs.

The rest depends on the quality of the writing. The SKILL.md body is your prompt: be precise, and include concrete examples of what the skill produces—an output example is worth more than three lines of description. Finally, test your skill on several cases, including a tricky one, before sharing it with the team.

Key takeaways

A skill is a directory with a SKILL.md file containing a YAML frontmatter
The frontmatter defines the name, description, allowed tools, and invocability
The Markdown body serves as both documentation and a prompt for Vibe
user-invocable: true makes the skill accessible via a slash command
Create specialized skills with the minimum necessary tools