Find Claude Code commands.
Copy what you need.

Start a session in a planning-oriented permission mode.

Choose how agent-team teammates are displayed.

Inject live command output into a skill before Claude reads the instructions.

Legacy custom commands remain supported, but skills are the recommended modern format.

Shared project settings, suitable for a trusted repository’s conventions.

Local-only project settings for machine- or developer-specific needs.

Store a project-scoped skill beside the codebase.

Store project-scope MCP server configuration that can be shared with a repository.

Grant access to an additional working directory during the current session.

Show current subagent guidance and direct you to create or edit agent definitions.

Detach the current work into a background agent and free the terminal.

Decompose a large codebase change and run independent units in parallel worktrees.

Branch the current conversation to explore a different direction.

Ask a side question without adding it to the main conversation history.

Relocate the session to another directory’s project storage.

Start a fresh task while retaining the project’s memory.

Review a diff for correctness bugs and cleanup opportunities.

Summarize context to reclaim space while continuing the same task.

Inspect settings or change specific supported options directly.

Inspect what is occupying the context window.

Diagnose a runtime issue using a targeted description and project context.

Inspect what changed before you ship or approve a larger operation.

Run a setup checkup for installation and configuration issues.

Adjust how much reasoning Claude applies to the task.

Use ultracode for a high-effort dynamic workflow, or include ultrathink for one-off deep reasoning.

Copy the conversation into a new background session while the current one continues.

Open the interactive panel for MCP server status and management.

Refine project memory and the instructions that guide later sessions.

Choose the active model for the session.

Switch into plan mode before a substantial change.

Return to an earlier conversation through the session picker.

Roll code and conversation back to an earlier checkpoint or summarize a previous segment.

Launch an application using inferred project conventions.

Capture a reliable run recipe as a per-project skill.

Check a diff for security vulnerabilities before release.

Hand a side task to a subagent that reports back into the current conversation.

List the current session’s background work and completed subagents.

Confirm changes against the running application rather than tests alone.

Stores OAuth session state, MCP configuration, project state, and caches.

Layered user settings that apply across projects.

Store a reusable personal skill available across projects.

Pass the user’s skill arguments into the skill instructions.

Start an interactive Claude Code session in the current directory.

Create a new Claude Code web session with a task description.

Continue the most recent conversation in the current directory.

Run a one-shot prompt, print the response, and exit.

Resume a named or identified session and optionally add a new instruction.

Open an interactive session with a first instruction already supplied.

Monitor and dispatch parallel background sessions.

Attach a background session to the current terminal.

View logs from a background session.

Access Claude Code’s MCP management and reference commands.

Add a remote HTTP MCP server—the recommended remote transport.

Add a local MCP server process using stdio transport.

Inspect configured servers and authenticate where supported.

Capture stable project context, conventions, and operating instructions.

Open transcript/verbose views, search history, open commands, enter direct shell mode, and mention files.

The required instruction file at the root of a Claude Code skill directory.

Review a repository before its local configuration or MCP servers receive trust.

Keep secrets local, document required variable names safely, and prevent commits of real credentials.

Use direct APIs for deterministic product integration; use MCP to connect an agent session to approved external tools and data.

State the user, problem, constraints, output, visual direction, and acceptance criteria before asking for implementation.

Treat an AI-produced first version as the start of a structured iteration loop, not the final artifact.

Use separate directories or worktrees for independent agents and changes.

Research established libraries and integrations before recreating a capability from scratch.

Use voice-to-text to formulate a richer first draft of a prompt, then review the resulting text before sending it.

Local folders, shell completions, and labels such as Code/Search/Test/Data were shown in the source material.

Uncorroborated examples found in secondary web material include /remove-dir, /voice_settings, /worktree_name, and custom autocomplete entries.