Claude Code ships more than 60 built-in slash commands, you will use about twelve, and the real leverage is in the ones you write yourself. That’s the whole thesis. Every list post on this topic dumps all 60 on you alphabetically; this one is organized by what you’ll actually type, because a command list you can’t prioritize is trivia, not tooling.

So here’s the Claude Code slash commands list worth bookmarking: the 18 built-ins that earn their place, grouped by job; the custom command format in both its legacy and current flavors; and the 7 custom commands from the 500k.io repo — the ones running a daily content factory — that you can copy in 10 minutes. I run these on Claude Code Max daily; my usage skews content-and-solo-founder, so calibrate the picks to your own stack. If you’re brand new to the terminal side, start with the beginner guide first.

The built-ins that matter (18 of 60+)

Session control: /clear, /compact, /resume, /rewind

These four manage the thing that actually limits long sessions — context. /clear wipes the conversation and starts fresh; use it between unrelated tasks, because carrying a debugging session’s context into a writing task degrades both. /compact summarizes the conversation in place, reclaiming context while keeping the thread — my rule is to run it when a session crosses roughly 50 messages. /resume reopens a previous session with its history intact, which beats re-explaining a half-finished migration. /rewind steps the conversation back to an earlier checkpoint when the last few exchanges went sideways.

The discipline that matters: /clear is not a failure state. New task, new context. Per DataCamp’s 2026 command guide, context hygiene commands are the most under-used category among new users — and the cheapest fix for “Claude got dumber over the session.”

Four commands, one job: keep the context window spending its budget on the current task.

Configuration: /model, /permissions, /config, /agents, /hooks, /memory

Six commands configure how Claude Code behaves. /model switches models mid-session — drop to a faster model for mechanical edits, back up for architecture calls. /permissions manages the tool allowlist, which beats clicking “approve” forty times a day; if a safe command prompts you three times, allowlist it. /config opens general settings, /agents creates and edits the subagents covered in the subagents tutorial, /hooks does the same for lifecycle hooks, and /memory edits the CLAUDE.md files that persist your project rules — the file format I broke down in how to write a CLAUDE.md.

Of the six, /permissions has the best effort-to-payoff ratio: five minutes of allowlisting the 10 read-only commands you approve daily removes 30-40 interruptions a week.

Configure once with /permissions and /memory; stop paying the same attention tax every session.

Diagnostics and workflow: /cost, /doctor, /init, /review, /help

Five more round out the working set. /init scaffolds a CLAUDE.md for a new repo by scanning the codebase — always my first command in a fresh project, and its output is a draft to edit, not a final file. /review runs a code review pass on your current diff. /cost shows token spend for the session (essential on API pricing, informational on Max). /doctor diagnoses installation and configuration problems — run it before blaming the model. /help lists every command with one-line explanations, including your custom ones.

That’s 15 named so far; add /bug (file a report to Anthropic), /mcp (manage MCP server connections), and /vim (modal editing in the input box) and you have the full 18. The remaining 40+ built-ins exist, and the community reference lists catalog them — but I’ve never needed them in nine months of daily use.

18 built-ins is the working set. Learn 5 this week (/clear, /compact, /model, /permissions, /agents) and add the rest on contact.

Custom commands: the actual leverage

The format: one Markdown file, $ARGUMENTS, done

A custom slash command is a Markdown file whose name becomes the command. Drop changelog.md into .claude/commands/ and /changelog appears in your menu; the file’s content becomes the prompt, and the $ARGUMENTS placeholder injects whatever you typed after the command name. Optional YAML frontmatter adds a description (shown in the menu) and tool restrictions. Per the official slash commands documentation, that’s the entire contract — a 5-line file is a working command:

---
description: Draft a conventional-commit message for staged changes
---
Look at the staged diff (git diff --cached) and draft a conventional
commit message. Subject under 65 chars. Context: $ARGUMENTS

The test for whether a prompt deserves to become a command: have you typed a close variant of it three times? Three repetitions means weekly recurrence, and a command turns a 90-second retype into a 3-second invocation. My seven custom commands each save 5-15 minutes per invocation against writing the equivalent prompt with full context from scratch.

If you’ve typed the same prompt three times, the fourth time should be a slash command.

The 2026 shift worth knowing: .claude/commands/ still works, but Anthropic now recommends the skill format — .claude/skills/<name>/SKILL.md — for new commands. A skill supports the identical /name invocation plus autonomous triggering: Claude loads it by itself when your task matches the skill’s description, no typing required. Same file, two entry points. The skill format also supports bundled resources (reference files, scripts, templates in the skill’s directory), which flat command files never did.

Migration is mechanical: move commands/review.md to skills/review/SKILL.md, add a description field with clear trigger conditions, done — /review keeps working exactly as before. I migrated the 500k.io repo in April 2026 in under an hour, and two of the seven commands started firing autonomously in situations where I’d previously forgotten to invoke them. That’s the practical difference: commands only work when you remember them.

Write new commands as skills: same slash invocation, plus Claude can fire them when you forget to.

The 7 from the 500k.io repo worth stealing

These run a daily content factory, so steal the shape even if your stack differs. /score — runs a draft through a 12-point quality rubric and returns a 0-100 score with the three highest-impact fixes; the ≥85 publish gate lives here. /ingest — takes a raw source (URL, PDF, notes) and files a structured summary into the knowledge base. /research — pulls the live SERP for a keyword and returns a dossier of citable data points with sources. /plan — turns research into a section-by-section article outline. /implement — executes a written plan with self-correction. /workflow — chains research → plan → implement in one shot for well-defined pieces. /context — audits what’s currently in the context window and suggests what to prune.

The pattern across all seven: each encodes a checklist I used to hold in my head, and each ends by stating what “done” looks like so the output is verifiable. Combined they save me a conservative 45-60 minutes a day — that’s the content engine’s margin, in seven Markdown files.

Steal the shape, not the files: every good command is a checklist you were already running mentally.

Build your first command in 10 minutes

The 10-minute version, step by step

Minute 0-2: find the prompt you retype most — check your history, it’s usually a review, a summary, or a formatting job. Minute 2-6: create .claude/skills/<name>/SKILL.md, paste your best version of that prompt as the body, add a two-line frontmatter with a “Use when” description, and put $ARGUMENTS where the variable part goes. Minute 6-8: test it — type /<name> with a real argument and compare the output against what your hand-typed version produced. Minute 8-10: fix the one thing that’s off (there’s always one thing — usually a missing output-format instruction), and commit the file so it’s versioned with your repo.

Common errors: a command that does two jobs (split it — one command, one checklist), a missing description (it works when typed but the menu shows nothing and autonomous invocation never fires), and prompts that assume context the command doesn’t carry (state everything; the file is the whole prompt).

Ten minutes, one file, one recurring prompt retired permanently.

The verdict: which commands to actually learn

Pulling the Claude Code slash commands list together into a decision path instead of trivia: week one, learn /clear, /compact, /model, /permissions, and /agents — that’s 90% of built-in value. Week two, run /init on your main repo and spend five minutes in /permissions allowlisting your safe daily commands. Week three, write your first custom skill from the prompt you retype most, and add one more each time you catch yourself retyping something. Skip memorizing the other 40+ built-ins; /help exists.

The founders getting outsized value from Claude Code aren’t the ones who know the most commands. They’re the ones who turned their own repeated judgment into files.

Related: Claude Code subagents explained, the hooks tutorial, and how to write a Claude skill step by step — or start from the complete Claude Code guide for the full map.

FAQ

How do I see all slash commands in Claude Code?

Type / in any session and the menu opens with every available command — built-ins plus anything in your .claude/commands/ or .claude/skills/ directories. Type /help for the annotated list. There are 60+ built-ins as of mid-2026; you'll use about a dozen weekly.

How do I create a custom slash command?

Two formats. Legacy: drop a Markdown file in .claude/commands/ — the filename becomes the command (review.md → /review) and $ARGUMENTS inserts whatever you type after it. Recommended since 2026: a skill at .claude/skills/<name>/SKILL.md, which supports the same /name invocation plus autonomous triggering by Claude.

What's the difference between a slash command and a skill?

A command file only fires when you type it. A skill can fire both ways — you type /name, or Claude loads it autonomously when the task matches its description. Skills are the superset; Anthropic now recommends them as the default format for new commands.

Do slash commands use my prompt or replace it?

The command file's content becomes the prompt, with $ARGUMENTS substituted by whatever you typed after the command name. /fix login bug with a fix.md template sends the template's text with 'login bug' injected where $ARGUMENTS sits.

Which built-in slash commands matter most day to day?

Five cover 90% of real usage: /clear (reset context between tasks), /compact (summarize a long session in place), /model (switch models mid-session), /permissions (manage tool allowlists), and /agents (create and edit subagents). Learn those before memorizing the rest.

Can slash commands take arguments?

Yes. $ARGUMENTS captures everything after the command name as one string. For finer control, $1 and $2 style positional arguments are supported in newer versions, and frontmatter can declare an argument-hint so the menu shows expected usage.