Slash commands: trigger skills in one gesture

Lesson updated November 2, 2026 based on Vibe documentation: a skill slash command appends the skill’s instructions to your message, and disable-model-invocation: true reserves a skill for manual triggering. Sources: Skills · Commands and shortcuts.

Shortcuts for your skills

The skills you wrote in previous lessons are useless unless something calls them. Slash commands are that trigger: commands prefixed with / that you type directly into the Vibe session. You don’t need to make any additional declarations—every skill with user-invocable: true in its frontmatter automatically generates a slash command bearing the skill’s name. You write the SKILL.md, and Vibe handles exposing it.

The syntax fits on one line: the command name, followed by what you want it to process.

# In an interactive Vibe session
/code-review src/api/auth.ts
/test-generator src/utils/helpers.ts
/doc-writer src/lib/database.ts

Vibe adds the instructions from SKILL.md to your message, along with the text you typed after the command. In addition to these commands derived from your skills, Vibe provides built-in commands available in every session:

/config          # Modify Vibe configuration
/help            # Display help
/clear           # New conversation (alias /new)
/model           # Choose the active model
/resume          # Resume a saved session
/compact         # Summarize history to free up context
/reload          # Reload configuration, instructions, and skills

Designing skills that chain together

A single slash command saves a few seconds. Chaining them is where the real gain lies: each skill picks up where the previous one left off. Let’s look at two complementary skills, one that cleans up code and another that commits it.

The first, lint-fix, assumes a project already has its tools configured and simply needs to orchestrate them in the right order.

---
name: lint-fix
description: Lint and format code using project rules
license: MIT
user-invocable: true
allowed-tools:
  - read_file
  - write_file
  - bash
  - grep
---

# Lint & Fix

Run the project's linter and formatter on the specified files.

## Process

1. Detect the linter (ESLint, Biome, oxlint)
2. Detect the formatter (Prettier, Biome)
3. Run linting with auto-fix
4. Run formatting
5. Report unfixable errors

The second, smart-commit, steps in once the code is clean. Note the presence of ask_user_question in its allowed tools: writing a commit message affects the repository history, so it’s legitimate for the skill to ask for validation before executing.

---
name: smart-commit
description: Generate a conventional commit message from changes
license: MIT
user-invocable: true
allowed-tools:
  - bash
  - read_file
  - grep
  - ask_user_question
---

# Smart Commit

Analyze current Git changes and generate a commit message
following the Conventional Commits convention.

## Process

1. Run `git diff --staged` to view changes
2. Categorize: feat, fix, refactor, docs, test, chore
3. Identify the scope (main file or module)
4. Write a concise message in English
5. Ask the user for validation
6. Execute the commit

Once these skills are in place, a development day looks like this: you open the session, explore existing code, write code, then run through the verification chain before committing.

vibe

# Morning: exploration
/code-review src/

# Development
# ... code ...

# Before commit
/lint-fix src/
/test-generator src/new-file.ts
/smart-commit

What you pass to the command

Everything after the command name is free text, passed to the skill as context. You can specify a single file, list several, or give an instruction in natural language instead of listing paths.

# Pass a specific file
/code-review src/api/users.ts

# Pass multiple files
/test-generator src/utils/math.ts src/utils/string.ts

# Pass instructions
/doc-writer Document only the public functions in src/lib/

Not all your skills need to become commands. An analysis skill called only by other skills or by an agent has no place in your auto-completion: set it to user-invocable: false, and it disappears from the list while remaining referenceable internally.

---
name: internal-analyzer
description: Internal analysis used by other skills
user-invocable: false
allowed-tools:
  - read_file
  - grep
---

Staying readable over time

Type / alone in a session to see the full list of available commands, both built-in and personal, with each name and description. This list is your dashboard: if you can’t find your own skills after three months, your naming has drifted. A verb-object convention is enough to keep everything consistent.

/lint-fix       → action-object
/test-generate  → action-object
/doc-write      → action-object
/db-migrate     → context-action

The frontmatter description appears in this auto-completion: it’s what will remind you, six months from now, exactly what the command does. “Testing tool” tells you nothing; the longer version tells you which framework, which language, and what scope.

# Bad
description: Testing tool

# Good
description: Generate Vitest unit tests for exported TypeScript functions

Key takeaways

• Every skill with user-invocable: true automatically generates a slash command
• Syntax: /skill-name optional-arguments
• Arguments are free text passed to the skill as context
• Combine slash commands to create daily workflows
• Type / to list all available commands
• Name your skills consistently and descriptively