Create custom slash commands to automate workflows and standardize team practices.

To get started, type / in Bob Shell to see all available commands, or create your own by adding a markdown file to .bob/commands/ or ~/.bob/commands/.

Built-in commands

Bob Shell includes the following built-in slash commands:

Command	Aliases	Description
`/help`		Show all available slash commands
`/clear`		Clear the screen and reset conversation history
`/condense`		Intelligently condense the context window to free up space
`/copy`		Copy an item from conversation history to the clipboard
`/mode`		Switch the active mode (opens a picker)
`/resume`		Browse and resume a previous conversation
`/settings`		View and edit Bob Shell settings
`/mcp`		Manage configured MCP servers
`/manage-secrets`		Manage secrets used in MCP server configurations
`/skills`		Insert a skill reference into the prompt
`/init`		Initialise Bob in the current workspace
`/status`		View session status, usage, and version information
`/team`		Select a team
`/logs`		Open the latest log file with the system viewer
`/docs`		Open Bob Shell documentation in your browser
`/bug`		Submit a bug report
`/exit`	`/quit`, `/close`	Exit the CLI

`/manage-secrets` subcommands

Secrets let you store sensitive values (such as API keys) and reference them in MCP server configurations without hardcoding them.

Subcommand	Usage	Description
`set`	`/manage-secrets set KEY VALUE`	Store a secret value
`list`	`/manage-secrets list`	List all stored secret keys
`rm`	`/manage-secrets rm KEY`	Remove a stored secret

Secrets are stored encrypted in ~/.bob/settings/ and can be referenced in MCP server configurations using ${KEY} syntax.

Why use slash commands?

Slash commands provide several key benefits:

Workflow automation: Turn complex multi-step processes into single commands

Team standardization: Share commands across your team for consistent practices

Context preservation: Include project-specific context in every command

Quick access: Fuzzy search and autocomplete for instant command discovery

How slash commands work

When you type / in Bob Shell, a menu appears showing all available commands. These commands come from two sources:

Command Type	Source	Purpose
Custom workflow commands	`.bob/commands/` or `~/.bob/commands/`	User-created automation for specific tasks
Mode commands	Built-in and custom modes	Switch Bob's operational context

Creating custom commands

Custom commands extend Bob's functionality by adding markdown files to specific directories:

Location	Scope	Path
Project-specific	Available in current project only	`.bob/commands/` in your workspace root
Global	Available in all projects	`~/.bob/commands/` in your home directory

The filename becomes the command name. For example:

.bob/commands/
├── review.md         → /review
├── test-api.md       → /test-api
└── deploy-check.md   → /deploy-check

Command name processing

When creating commands through the UI, Bob Shell automatically processes command names:

Converts to lowercase

Replaces spaces with dashes

Removes special characters

Removes leading and trailing dashes

Example: "My Cool Command!" becomes my-cool-command

Basic command format

Create a simple command by adding a markdown file:

Help me review this code for security issues and suggest improvements.

Advanced command with frontmatter

Add metadata using frontmatter for enhanced functionality:

---
description: Create a new API endpoint
argument-hint: <endpoint-name> <http-method>
---
Create a new API endpoint called $1 that handles $2 requests.
Include proper error handling and documentation.

Frontmatter fields

Field	Purpose	Example
`description`	Appears in the command menu	"Create a new API endpoint"
`argument-hint`	Shows expected arguments	"`<endpoint-name>` `<http-method>`"

Tool approval dialog

When Bob Shell requests to use a tool, an approval dialog appears. The dialog provides the following options:

Option	Description
Approve Once	Allow this specific tool call to proceed. You will be prompted again for future calls.
Approve `<group>` tools for task	Allow all tools in the same tool group for the remainder of the task. Not shown for MCP tools.
Always Allow Command for task	Allow a specific shell command for the remainder of the task.
Reject	Deny the tool call. Bob Shell does not proceed with the action.

You can also add an optional note when approving or rejecting a tool call. The note is included in the conversation context so Bob Shell can adjust its behavior accordingly.

To interrupt a streaming response before Bob Shell finishes, press Esc.

Command management in Bob Shell

Bob Shell supports the same slash commands as Bob IDE. While Bob Shell does not provide a dedicated UI for managing commands, you can:

Create command files manually in the .bob/commands/ directory in your project or ~/.bob/commands/ in your home directory

Edit existing command files with any text editor

Using slash commands

Type / in Bob Shell to see a unified menu containing the following types of commands:

Unified menu: Custom commands and mode-switching commands appear together

Autocomplete: Start typing to filter commands (e.g., /sam shows sample-command-name)

Fuzzy search: Find commands even with partial matches

Description preview: See command descriptions in the menu

Visual indicators: Mode commands are distinguished from custom commands with special icons

/mode code     Switch to Code mode
/mode ask      Switch to Ask mode
/review        Review code for security issues
/api-endpoint  <endpoint-name> <http-method>

Argument hints

Argument hints provide instant help for slash commands, showing you what kind of information to provide when a command expects additional input.

When you type / to bring up the command menu, commands that expect arguments will display a light gray hint next to them. This hint tells you what kind of argument the command is expecting.

For example:

/mode <mode_slug> - The hint <mode_slug> indicates you should provide a mode name like code or debug

/api-endpoint <endpoint-name> <http-method> - Shows you need both an endpoint name and HTTP method

After selecting the command, it will be inserted into the chat input followed by a space. The hint is not inserted; it is only a visual guide to help you know what to type next. You must then manually type the argument after the command.

Adding argument hints to custom commands

You can add argument hints to your custom commands using the argument-hint field in the frontmatter:

---
description: Create a new API endpoint
argument-hint: <endpoint-name> <http-method>
---
Create a new API endpoint called $1 that handles $2 requests.
Include proper error handling and documentation.

This will display as /api-endpoint <endpoint-name> <http-method> in the command menu.

Best practices for argument hints

Be specific: Use descriptive placeholders like <file-path> instead of generic ones like <arg>

Show multiple arguments: If your command needs multiple inputs, show them all: <source> <destination>

Use consistent format: Always wrap placeholders in angle brackets: <placeholder>

Keep it concise: Hints should be brief and clear

Common questions about arguments

Question	Answer
What if I don't provide the argument?	The command might not work as expected, or it might prompt you for more information. The hint is there to help you get it right the first time.
Do all commands have hints?	No, only commands that are designed to take arguments will have hints. Commands that work without additional input won't show hints.
Can I use a command without replacing the hint?	The hint text (like `<mode_slug>`) needs to be replaced with actual values. Leaving the hint text will likely cause the command to fail or behave unexpectedly.

Best practices

Command naming

Use descriptive, action-oriented names

Keep names concise but clear

Use hyphens for multi-word commands

Avoid generic names like help or test

Note: Names are automatically slugified (lowercase, special characters removed)

The .md extension is automatically added/removed as needed

Command content

Start with a clear directive

Use structured formats (lists, sections)

Include specific requirements

Reference project conventions

Keep commands focused on a single task

Organization

Group related commands in subdirectories

Use consistent naming patterns

Document complex commands

Version control your commands

Share team commands in the project repository

Troubleshooting

Commands not appearing

If your commands aren't showing up in the menu:

Check file location: Ensure custom command files are in .bob/commands/ or ~/.bob/commands/

Verify file extension: Custom commands must be .md files

Command not found

When a slash command isn't found, the LLM will see:

The slash command '/unknown-command' was not found. Please check the command name and try again.

Command conflicts

Custom project commands override global custom commands with the same name

Use unique names to avoid conflicts

When creating duplicate names through the UI, numbers are appended (e.g., new-command-1, new-command-2)

About mode commands

The slash menu includes mode-switching commands (like /mode code, /mode ask) that fundamentally change the AI's operational mode - they don't just inject text but switch the entire AI context. Custom modes you create also appear as slash commands (e.g., a mode with slug reviewer becomes /reviewer). These mode commands cannot be overridden by custom workflow commands.

Cross-platform compatibility

Slash commands work identically across both Bob Shell and Bob IDE. This means:

Commands created in one environment can be used in the other

The same command syntax and behavior applies in both environments

Team-shared commands work consistently regardless of which interface team members use

Slash commands

On this page