{"id":2968,"date":"2026-04-25T18:55:54","date_gmt":"2026-04-25T18:55:54","guid":{"rendered":"https:\/\/aiopsschool.com\/blog\/?p=2968"},"modified":"2026-04-25T18:55:54","modified_gmt":"2026-04-25T18:55:54","slug":"the-master-tutorial-every-claude-code-slash-command-explained-april-2026-edition","status":"publish","type":"post","link":"https:\/\/aiopsschool.com\/blog\/the-master-tutorial-every-claude-code-slash-command-explained-april-2026-edition\/","title":{"rendered":"The Master Tutorial: Every Claude Code Slash Command Explained (April 2026 Edition)"},"content":{"rendered":"\n

If you’ve ever opened Claude Code, typed \/<\/code>, and watched a long menu of commands appear, you’re not alone in feeling slightly overwhelmed. This guide is the complete map. Every built-in command, every bundled skill, what it does, when to use it, and the gotchas nobody tells you about.<\/p>\n\n\n\n

This tutorial is current as of April 2026<\/strong> and is based on Anthropic’s official Claude Code documentation. Your exact menu may vary slightly depending on your version, installed plugins, and connected MCP servers \u2014 when in doubt, type \/help<\/code> in your session to see what’s actually available to you.<\/p>\n\n\n\n

\n\n\n\n

Table of Contents<\/h2>\n\n\n\n
    \n
  1. What slash commands actually are<\/li>\n\n\n\n
  2. Session and context management commands<\/li>\n\n\n\n
  3. Project setup and memory commands<\/li>\n\n\n\n
  4. Code review and quality commands<\/li>\n\n\n\n
  5. Configuration and customization commands<\/li>\n\n\n\n
  6. Model and execution control commands<\/li>\n\n\n\n
  7. Extension and integration commands<\/li>\n\n\n\n
  8. Bundled skills (the prompt-based commands)<\/li>\n\n\n\n
  9. Custom commands and skills you create yourself<\/li>\n\n\n\n
  10. MCP server commands<\/li>\n\n\n\n
  11. Special syntax: @<\/code>, !<\/code>, and #<\/code><\/li>\n\n\n\n
  12. Tips, gotchas, and best practices<\/li>\n<\/ol>\n\n\n\n
    \n\n\n\n

    1. What Slash Commands Actually Are<\/h2>\n\n\n\n

    A slash command is a typed shortcut you use inside a Claude Code session. You hit \/<\/code>, an autocomplete menu appears, and you pick or type the command you want. They fall into a few buckets:<\/p>\n\n\n\n

    Built-in commands<\/strong> ship with Claude Code itself and run fixed logic \u2014 things like clearing your conversation or compacting context. They’re hardcoded and fast.<\/p>\n\n\n\n

    Bundled skills<\/strong> also ship with Claude Code, but they’re prompt-based. They give Claude a detailed playbook and let it orchestrate the work using its tools. They look like commands when you type \/<\/code>, but they’re really mini-instructions Claude executes intelligently.<\/p>\n\n\n\n

    Custom commands<\/strong> are anything you create yourself in .claude\/commands\/<\/code> or .claude\/skills\/<\/code>. As of the 2026 update, these two have been unified \u2014 they both create a \/your-command-name<\/code> and work the same way.<\/p>\n\n\n\n

    MCP commands<\/strong> come from connected Model Context Protocol servers (GitHub, Slack, Atlassian, etc.) and appear as \/mcp__servername__promptname<\/code>.<\/p>\n\n\n\n

    Understanding which bucket a command falls into helps you predict its behavior. Built-ins are deterministic. Skills and custom commands are flexible but rely on Claude’s reasoning.<\/p>\n\n\n\n

    \n\n\n\n

    2. Session and Context Management Commands<\/h2>\n\n\n\n

    These are the commands you’ll touch most often. Master them first.<\/p>\n\n\n\n

    \/help<\/code><\/h3>\n\n\n\n

    Shows every command available in your current session \u2014 built-ins, bundled skills, your custom commands, and any MCP server prompts. This is your “I forgot what’s possible” command. Use it whenever you want to see the actual live list rather than trusting any cheat sheet (including this one).<\/p>\n\n\n\n

    \/clear<\/code><\/h3>\n\n\n\n

    Wipes your conversation history and starts a fresh session. Use this when you switch tasks. Many experienced users describe \/clear<\/code> as the single biggest token-saver in their workflow \u2014 every time you start something new, clear the chat. You don’t need yesterday’s bug-hunt context polluting today’s feature work.<\/p>\n\n\n\n

    Rule of thumb:<\/strong> if your next prompt has nothing to do with the previous one, run \/clear<\/code> first.<\/p>\n\n\n\n

    \/compact<\/code><\/h3>\n\n\n\n

    Summarizes older messages while preserving important context. Use this when you want continuity but your context window is getting full. You can pass an argument telling Claude what to retain:<\/p>\n\n\n\n

    \/compact retain the error handling patterns and the database schema\n<\/code><\/pre>\n\n\n\n
    The general guidance is: use \/compact<\/code> when context usage exceeds about 80%, and \/clear<\/code> when switching tasks entirely.<\/p>\n\n\n\n
    \/context<\/code><\/h3>\n\n\n\n
    Shows current context window usage. Useful when you’re trying to decide whether to keep going, run \/compact<\/code>, or \/clear<\/code> and start over.<\/p>\n\n\n\n
    \/cost<\/code><\/h3>\n\n\n\n
    Displays token usage and cost for the current session. Good for keeping an eye on spend, especially if you’re on API billing rather than a Pro\/Max subscription.<\/p>\n\n\n\n
    \/usage<\/code><\/h3>\n\n\n\n
    Shows your usage data more broadly \u2014 different from \/cost<\/code> in that it can cover usage across sessions, not just the current one.<\/p>\n\n\n\n
    \/status<\/code><\/h3>\n\n\n\n
    Quick view of session status: model in use, mode, current configuration, etc.<\/p>\n\n\n\n
    \/export<\/code><\/h3>\n\n\n\n
    Exports the current conversation. Great after solving a tricky problem \u2014 exported conversations become searchable documentation and learning resources for your future self.<\/p>\n\n\n\n
    \n\n\n\n
    3. Project Setup and Memory Commands<\/h2>\n\n\n\n
    These commands deal with how Claude Code remembers and understands your project.<\/p>\n\n\n\n
    \/init<\/code><\/h3>\n\n\n\n
    Scans your project and auto-generates a CLAUDE.md<\/code> file containing your directory structure, common commands, and coding conventions. Run this first in any new project.<\/strong> Setting up CLAUDE.md<\/code> from the beginning saves countless correction cycles later \u2014 Claude won’t have to re-figure-out “is there a build command? a lint command?” every session.<\/p>\n\n\n\n
    \/memory<\/code><\/h3>\n\n\n\n
    Opens an editor interface to edit your CLAUDE.md<\/code> files. Content written here persists across sessions. Use this when you want to add project conventions, architecture notes, or any context Claude should always know.<\/p>\n\n\n\n
    You can also use the #<\/code> prefix in normal chat for quick memory adds \u2014 just type # always use single quotes in JS<\/code> and it gets added.<\/p>\n\n\n\n
    \n\n\n\n
    4. Code Review and Quality Commands<\/h2>\n\n\n\n
    \/review<\/code><\/h3>\n\n\n\n
    Runs a code review on your changes. Claude analyzes the diff and gives you feedback on quality, readability, potential bugs, and so on.<\/p>\n\n\n\n
    \/security-review<\/code><\/h3>\n\n\n\n
    Same idea but laser-focused on security: SQL injection risks, XSS vulnerabilities, exposed credentials, insecure configurations, authentication issues. Run this before merging anything sensitive.<\/p>\n\n\n\n
    \/install-github-app<\/code><\/h3>\n\n\n\n
    Installs the Claude GitHub app so Claude automatically reviews your PRs. This is genuinely useful \u2014 Claude tends to find actual logic errors and security issues rather than nitpicking variable names like human reviewers sometimes do. After install, customize the review prompt in claude-code-review.yml<\/code> to keep it concise.<\/p>\n\n\n\n
    \n\n\n\n
    5. Configuration and Customization Commands<\/h2>\n\n\n\n
    \/config<\/code><\/h3>\n\n\n\n
    Edit your configuration. Changes persist to ~\/.claude\/settings.json<\/code> with project\/local\/policy override precedence \u2014 meaning project settings can override personal ones, and managed\/policy settings can override both.<\/p>\n\n\n\n
    \/permissions<\/code><\/h3>\n\n\n\n
    Manage allow\/deny rules for tools. Pre-approve common operations so Claude isn’t asking permission every five minutes when it wants to run git status<\/code>. Save your attention for the important decisions.<\/p>\n\n\n\n
    Example permission setup:<\/p>\n\n\n\n
      \n
    • Allow Bash(git *)<\/code> so all git commands run without prompts<\/li>\n\n\n\n
    • Deny Read(.\/.env)<\/code> and Read(.\/.env.*)<\/code> so secrets stay safe<\/li>\n\n\n\n
    • Deny Write(.\/production.config.*)<\/code> so production configs can’t be edited accidentally<\/li>\n<\/ul>\n\n\n\n
      \/hooks<\/code><\/h3>\n\n\n\n
      Opens an interactive menu to configure hooks \u2014 scripts that run at specific lifecycle events (before tool use, after file writes, etc.). Examples: run Prettier after every file write, run a type check after every edit, send a desktop notification when a long task finishes.<\/p>\n\n\n\n
      \/keybindings<\/code><\/h3>\n\n\n\n
      Create or edit ~\/.claude\/keybindings.json<\/code> to customize keyboard shortcuts. Changes take effect immediately without restarting Claude Code.<\/p>\n\n\n\n
      \n\n\n\n
      6. Model and Execution Control Commands<\/h2>\n\n\n\n
      \/model<\/code><\/h3>\n\n\n\n
      Lists available models and lets you switch. As of April 2026 the main options inside Claude Code are:<\/p>\n\n\n\n
        \n
      • Claude Sonnet 4.6<\/strong> \u2014 the daily-driver default. Strong on most prompts.<\/li>\n\n\n\n
      • Claude Haiku 4.5<\/strong> \u2014 fast and cheap, great for easy tasks.<\/li>\n\n\n\n
      • Claude Opus 4.6<\/strong> \u2014 the most capable, save for hard reasoning and complex multi-step coding.<\/li>\n\n\n\n
      • Claude Opus 4.7<\/strong> \u2014 the newest and most advanced model in the Claude 4.7 family.<\/li>\n<\/ul>\n\n\n\n
        Most Pro\/Max users default to Sonnet and only reach for Opus on hard problems.<\/p>\n\n\n\n
        \/effort<\/code><\/h3>\n\n\n\n
        Sets the effort level for the current session. Options: low<\/code>, medium<\/code>, high<\/code>, max<\/code>. Higher effort = more thinking, better results, more tokens. The max<\/code> level is Opus-only.<\/p>\n\n\n\n
        \/plan<\/code><\/h3>\n\n\n\n
        Toggles plan mode. In plan mode, Claude proposes an approach before doing anything destructive. Useful for big refactors. You can also cycle plan mode on\/off with Shift+Tab<\/code>.<\/p>\n\n\n\n
        \/agents<\/code><\/h3>\n\n\n\n
        Manage subagents \u2014 specialized Claude instances with their own context windows and personas. Use them for domain-specific tasks (code review, debugging, architecture exploration) so your main conversation stays focused and you save tokens.<\/p>\n\n\n\n
        Built-in agent types include Explore<\/code> (read-only codebase exploration), Plan<\/code> (planning without executing), and general-purpose<\/code>. You can also define your own in .claude\/agents\/<\/code>.<\/p>\n\n\n\n
        \/todos<\/code><\/h3>\n\n\n\n
        View the current TODO list Claude is tracking for the task at hand.<\/p>\n\n\n\n
        \n\n\n\n
        7. Extension and Integration Commands<\/h2>\n\n\n\n
        \/mcp<\/code><\/h3>\n\n\n\n
        Manage connected Model Context Protocol servers. MCP is how Claude Code talks to external tools \u2014 GitHub, Slack, databases, browsers, design tools, anything with an MCP integration. Use this to list, add, remove, or troubleshoot connections.<\/p>\n\n\n\n
        Add servers from the CLI:<\/p>\n\n\n\n
        claude mcp add --transport http github https:\/\/mcp.github.com\n<\/code><\/pre>\n\n\n\n
        Then manage them inside a session with \/mcp<\/code>.<\/p>\n\n\n\n
        \/plugin<\/code><\/h3>\n\n\n\n
        Add plugin marketplaces and install plugins. A plugin is a bundle of related slash commands, agents, skills, and hooks distributed together as a public Git repo. Anthropic hosts an official Claude Code Plugins marketplace, and the community has built many more.<\/p>\n\n\n\n
        Example flow:<\/p>\n\n\n\n
        \/plugin marketplace add https:\/\/github.com\/wshobson\/agents\n\/plugin install claude-code-plugin\n<\/code><\/pre>\n\n\n\n
        \/skills<\/code><\/h3>\n\n\n\n
        Manage installed skills \u2014 list them, see what’s available, debug skills that aren’t triggering. Skills are the prompt-based extensions that live in .claude\/skills\/<name>\/SKILL.md<\/code>.<\/p>\n\n\n\n
        \n\n\n\n
        8. Bundled Skills (Prompt-Based Commands)<\/h2>\n\n\n\n
        These ship with Claude Code but are skills under the hood. They’re listed alongside built-ins in the commands reference (marked “Skill” in the Purpose column) and you invoke them like any other command.<\/p>\n\n\n\n
        \/simplify<\/code><\/h3>\n\n\n\n
        Simplifies code. Claude reads what you point it at and refactors for clarity \u2014 fewer abstractions, clearer names, less cleverness.<\/p>\n\n\n\n
        \/batch<\/code><\/h3>\n\n\n\n
        Runs batched operations. Useful for “do X to all files matching Y” kinds of tasks where you want predictable, repeated handling rather than improvisation.<\/p>\n\n\n\n
        \/debug<\/code><\/h3>\n\n\n\n
        Debugs a problem. Claude takes a structured approach: reproduce, isolate, hypothesize, test, fix. This is much better than just describing your bug in chat because the skill enforces a real debugging methodology.<\/p>\n\n\n\n
        \/loop<\/code><\/h3>\n\n\n\n
        Runs iterative loops. Claude works on something repeatedly until a specification is met or a condition is satisfied. Pairs well with autonomous coding workflows.<\/p>\n\n\n\n
        \/claude-api<\/code><\/h3>\n\n\n\n
        Helps with the Anthropic\/Claude API itself \u2014 writing code that calls the API, debugging API issues, exploring features like tool use, batch processing, MCP, and so on.<\/p>\n\n\n\n
        \n\n\n\n
        9. Custom Commands and Skills You Create<\/h2>\n\n\n\n
        Beyond the built-ins, you can create your own. As of the 2026 update, custom commands and skills have been unified \u2014 they both create a \/your-command<\/code> and work the same way.<\/p>\n\n\n\n
        Creating a custom command (the simple way)<\/h3>\n\n\n\n
        Create a markdown file in one of two locations:<\/p>\n\n\n\n
          \n
        • Project-scoped:<\/strong> .claude\/commands\/my-command.md<\/code> (shared via git, project-specific)<\/li>\n\n\n\n
        • Personal:<\/strong> ~\/.claude\/commands\/my-command.md<\/code> (available across all your projects)<\/li>\n<\/ul>\n\n\n\n
          The file becomes \/my-command<\/code>. The contents are the prompt Claude follows when you invoke it. Use $ARGUMENTS<\/code> to capture whatever you type after the command name.<\/p>\n\n\n\n
          Example .claude\/commands\/optimize.md<\/code>:<\/p>\n\n\n\n
          Analyze this code for performance issues:\n\n$ARGUMENTS\n\nFor each issue you find, suggest a specific fix with example code.\n<\/code><\/pre>\n\n\n\n
          Now \/optimize src\/api\/users.ts<\/code> runs that prompt with the file path inserted.<\/p>\n\n\n\n
          Creating a skill (the more powerful way)<\/h3>\n\n\n\n
          A skill is a directory rather than a single file. It can include supporting files like reference docs, scripts, and templates.<\/p>\n\n\n\n
          ~\/.claude\/skills\/explain-code\/\n\u251c\u2500\u2500 SKILL.md           # Main instructions (required)\n\u251c\u2500\u2500 examples.md        # Loaded only when needed\n\u2514\u2500\u2500 scripts\/\n    \u2514\u2500\u2500 visualize.py   # Script Claude can execute\n<\/code><\/pre>\n\n\n\n
          SKILL.md<\/code> has YAML frontmatter that controls behavior:<\/p>\n\n\n\n
          ---\nname: explain-code\ndescription: Explains code with visual diagrams and analogies. Use when explaining how code works.\ndisable-model-invocation: false\nallowed-tools: Read Grep\n---\n\nWhen explaining code, always include an analogy, an ASCII diagram,\na step-by-step walkthrough, and a common gotcha.\n<\/code><\/pre>\n\n\n\n
          Key frontmatter fields:<\/p>\n\n\n\n
            \n
          • name<\/code><\/strong> \u2014 becomes the slash command. Lowercase letters, numbers, hyphens only.<\/li>\n\n\n\n
          • description<\/code><\/strong> \u2014 what the skill does. Claude uses this to decide when to load it automatically. Front-load the key use case; descriptions get truncated past 250 characters.<\/li>\n\n\n\n
          • disable-model-invocation: true<\/code><\/strong> \u2014 only you can invoke it. Use for \/deploy<\/code>, \/commit<\/code>, \/send-slack-message<\/code> \u2014 anything with side effects you don’t want Claude triggering on its own.<\/li>\n\n\n\n
          • user-invocable: false<\/code><\/strong> \u2014 only Claude can invoke it. Use for background knowledge that isn’t a meaningful action for users.<\/li>\n\n\n\n
          • allowed-tools<\/code><\/strong> \u2014 tools Claude can use without per-use approval when this skill is active.<\/li>\n\n\n\n
          • model<\/code><\/strong> \u2014 the model to use when this skill runs.<\/li>\n\n\n\n
          • effort<\/code><\/strong> \u2014 effort level when active (low<\/code>\/medium<\/code>\/high<\/code>\/max<\/code>).<\/li>\n\n\n\n
          • context: fork<\/code><\/strong> \u2014 runs the skill in an isolated subagent context.<\/li>\n\n\n\n
          • agent<\/code><\/strong> \u2014 which subagent type to use when forking (Explore<\/code>, Plan<\/code>, general-purpose<\/code>, or a custom one).<\/li>\n\n\n\n
          • paths<\/code><\/strong> \u2014 glob patterns that limit when the skill activates.<\/li>\n\n\n\n
          • argument-hint<\/code><\/strong> \u2014 autocomplete hint for expected arguments, e.g. [issue-number]<\/code>.<\/li>\n<\/ul>\n\n\n\n
            Where skills live<\/h3>\n\n\n\n
            Higher-priority locations override lower ones when names collide:<\/p>\n\n\n\n
            Location<\/th>Path<\/th>Applies to<\/th><\/tr><\/thead>
            Enterprise<\/td>(managed settings)<\/td>All users in the org<\/td><\/tr>
            Personal<\/td>~\/.claude\/skills\/<name>\/SKILL.md<\/code><\/td>All your projects<\/td><\/tr>
            Project<\/td>.claude\/skills\/<name>\/SKILL.md<\/code><\/td>This project only<\/td><\/tr>
            Plugin<\/td><plugin>\/skills\/<name>\/SKILL.md<\/code><\/td>Wherever the plugin is enabled<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
            Precedence: enterprise > personal > project. Plugin skills use a plugin-name:skill-name<\/code> namespace so they can’t conflict.<\/p>\n\n\n\n
            String substitutions inside skill content<\/h3>\n\n\n\n
              \n
            • $ARGUMENTS<\/code><\/strong> \u2014 everything you typed after the command name<\/li>\n\n\n\n
            • $ARGUMENTS[0]<\/code><\/strong>, $ARGUMENTS[1]<\/code><\/strong>, etc. \u2014 individual arguments by index<\/li>\n\n\n\n
            • $0<\/code><\/strong>, $1<\/code><\/strong>, etc. \u2014 shorthand for the above<\/li>\n\n\n\n
            • ${CLAUDE_SESSION_ID}<\/code><\/strong> \u2014 current session ID<\/li>\n\n\n\n
            • ${CLAUDE_SKILL_DIR}<\/code><\/strong> \u2014 directory containing the SKILL.md<\/li>\n<\/ul>\n\n\n\n
              So \/migrate-component SearchBar React Vue<\/code> with content Migrate $0 from $1 to $2<\/code> becomes Migrate SearchBar from React to Vue<\/code>.<\/p>\n\n\n\n
              Dynamic context injection<\/h3>\n\n\n\n
              Use !`<command>`<\/code> syntax to run shell commands before the skill content reaches Claude. The output replaces the placeholder.<\/p>\n\n\n\n
              ## PR context\n- Diff: !`gh pr diff`\n- Comments: !`gh pr view --comments`\n\n## Your task\nSummarize this pull request...\n<\/code><\/pre>\n\n\n\n
              Each !`...`<\/code> runs first; Claude sees the actual PR data, not the command.<\/p>\n\n\n\n
              \n\n\n\n
              10. MCP Server Commands<\/h2>\n\n\n\n
              When you connect an MCP server, its prompts appear as slash commands automatically:<\/p>\n\n\n\n
              \/mcp__github__create-issue\n\/mcp__slack__send-message\n\/mcp__atlassian__find-jira-ticket\n<\/code><\/pre>\n\n\n\n
              The format is always \/mcp__<server>__<prompt><\/code>. They’re discovered dynamically \u2014 connect a new server and its commands show up; disconnect and they vanish.<\/p>\n\n\n\n
              Common MCP servers people connect:<\/p>\n\n\n\n
                \n
              • GitHub<\/strong> \u2014 issues, PRs, code search<\/li>\n\n\n\n
              • Slack<\/strong> \u2014 read\/send messages, search channels<\/li>\n\n\n\n
              • Google Drive \/ Calendar<\/strong> \u2014 files and events<\/li>\n\n\n\n
              • Atlassian (Jira\/Confluence)<\/strong> \u2014 tickets and docs<\/li>\n\n\n\n
              • Miro<\/strong> \u2014 diagrams and boards<\/li>\n<\/ul>\n\n\n\n
                \n\n\n\n
                11. Special Syntax: @<\/code>, !<\/code>, and #<\/code><\/h2>\n\n\n\n
                Not technically slash commands, but they live in the same input box and worth knowing.<\/p>\n\n\n\n
                @<\/code> \u2014 file\/directory mentions<\/h3>\n\n\n\n
                Type @<\/code> and Claude Code autocompletes file and directory paths from your project. Use it to give precise context without copy-paste:<\/p>\n\n\n\n
                Refactor @src\/auth\/login.ts to use the patterns in @src\/auth\/signup.ts\n<\/code><\/pre>\n\n\n\n
                You can also @<\/code> URLs and Git references in modern versions.<\/p>\n\n\n\n
                !<\/code> \u2014 direct shell commands<\/h3>\n\n\n\n
                Prefix with !<\/code> to run a shell command directly, bypassing Claude’s conversational mode:<\/p>\n\n\n\n
                !ls -la src\/\n!npm test\n<\/code><\/pre>\n\n\n\n
                This is more token-efficient than asking Claude “can you list the files in src” because Claude doesn’t need to think about it \u2014 it just runs.<\/p>\n\n\n\n
                #<\/code> \u2014 quick memory adds<\/h3>\n\n\n\n
                Prefix with #<\/code> to add something to CLAUDE.md<\/code> instantly:<\/p>\n\n\n\n
                # Always use TypeScript strict mode in this project\n# The staging API is at staging-api.example.com\n<\/code><\/pre>\n\n\n\n
                Future you (and future Claude) will be grateful.<\/p>\n\n\n\n
                \n\n\n\n
                12. Tips, Gotchas, and Best Practices<\/h2>\n\n\n\n
                A few hard-won lessons from people who use Claude Code daily:<\/p>\n\n\n\n
                Start every project with \/init<\/code>.<\/strong> Generating CLAUDE.md<\/code> upfront prevents Claude from re-discovering your project conventions every session. The token savings alone pay for it.<\/p>\n\n\n\n
                Use \/clear<\/code> aggressively.<\/strong> When you switch tasks, clear. There’s no benefit to dragging old context into a new problem, and Claude will spend tokens running auto-compaction trying to summarize it.<\/p>\n\n\n\n
                \/compact<\/code> for continuity, \/clear<\/code> for clean slates.<\/strong> Different tools, different jobs.<\/p>\n\n\n\n
                Add disable-model-invocation: true<\/code> to anything with side effects.<\/strong> You don’t want Claude deciding to deploy because your code “looks ready.”<\/p>\n\n\n\n
                Pre-approve safe tools in \/permissions<\/code>.<\/strong> Routine git commands, common build tools, read operations on code files. Reserve permission prompts for things that actually matter.<\/p>\n\n\n\n
                Skill descriptions are loaded into context \u2014 keep them tight.<\/strong> Front-load the key use case. Anything past 250 characters gets truncated in the skill listing.<\/p>\n\n\n\n
                Skills get re-attached after compaction, but only the most recent invocation of each.<\/strong> If a skill’s behavior fades after a long session, re-invoke it.<\/p>\n\n\n\n
                Use \/agents<\/code> and subagents for big exploration.<\/strong> Forking to a subagent keeps your main conversation clean and prevents context pollution. The Explore<\/code> agent is especially good for “go read the codebase and tell me how X works.”<\/p>\n\n\n\n
                \/help<\/code> is the source of truth.<\/strong> This article is current as of April 2026, but Anthropic ships updates frequently. When in doubt, \/help<\/code> shows you what’s actually in your version.<\/p>\n\n\n\n
                Set SLASH_COMMAND_TOOL_CHAR_BUDGET<\/code> if you have many skills.<\/strong> The default budget is 1% of the context window with an 8,000 character fallback. If your skill descriptions are getting truncated and Claude isn’t matching them well, raise this limit.<\/p>\n\n\n\n
                \n\n\n\n
                Closing Thoughts<\/h2>\n\n\n\n
                Claude Code’s slash command system is genuinely well-designed \u2014 there’s a clear separation between deterministic built-ins, prompt-based skills, custom extensions, and external integrations via MCP. Once you internalize that taxonomy, the tool stops feeling like a black hole and starts feeling like a programmable environment.<\/p>\n\n\n\n
                The commands you’ll use 90% of the time are a small subset: \/clear<\/code>, \/compact<\/code>, \/init<\/code>, \/memory<\/code>, \/model<\/code>, \/review<\/code>. Master those first. The rest are there when you need them.<\/p>\n\n\n\n
                For the live, always-current reference, the official docs are at:<\/p>\n\n\n\n
                  \n
                • Slash commands:<\/strong> https:\/\/code.claude.com\/docs\/en\/slash-commands<\/li>\n\n\n\n
                • Commands reference:<\/strong> https:\/\/code.claude.com\/docs\/en\/commands<\/li>\n\n\n\n
                • Claude Code overview:<\/strong> https:\/\/docs.claude.com\/en\/docs\/claude-code\/overview<\/li>\n<\/ul>\n\n\n\n
                  Happy coding.<\/p>\n","protected":false},"excerpt":{"rendered":"
                  If you’ve ever opened Claude Code, typed \/, and watched a long menu of commands appear, you’re not alone in […]<\/p>\n","protected":false},"author":4,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[1],"tags":[],"class_list":["post-2968","post","type-post","status-publish","format-standard","hentry","category-uncategorized"],"_links":{"self":[{"href":"https:\/\/aiopsschool.com\/blog\/wp-json\/wp\/v2\/posts\/2968","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/aiopsschool.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/aiopsschool.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/aiopsschool.com\/blog\/wp-json\/wp\/v2\/users\/4"}],"replies":[{"embeddable":true,"href":"https:\/\/aiopsschool.com\/blog\/wp-json\/wp\/v2\/comments?post=2968"}],"version-history":[{"count":1,"href":"https:\/\/aiopsschool.com\/blog\/wp-json\/wp\/v2\/posts\/2968\/revisions"}],"predecessor-version":[{"id":2969,"href":"https:\/\/aiopsschool.com\/blog\/wp-json\/wp\/v2\/posts\/2968\/revisions\/2969"}],"wp:attachment":[{"href":"https:\/\/aiopsschool.com\/blog\/wp-json\/wp\/v2\/media?parent=2968"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/aiopsschool.com\/blog\/wp-json\/wp\/v2\/categories?post=2968"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/aiopsschool.com\/blog\/wp-json\/wp\/v2\/tags?post=2968"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}