Claude Code gets a lot faster once you stop treating it like a plain chat box and start using its slash commands as control surfaces. The best commands are not flashy. They remove friction: clear the session when context is stale, compact the conversation when it gets long, open settings when the session needs a different model, and jump straight into a debug or diff workflow when the task is already obvious.
That is the real value of slash commands. They reduce setup time and keep Claude focused on the job instead of the history around the job.
Why slash commands matter
Claude Code is designed for work that changes over time: code edits, terminal tasks, reviews, troubleshooting, and multi-step refactors. If you keep typing everything as a free-form prompt, you spend more time explaining the environment than asking for the actual task.
Slash commands solve that by turning common actions into explicit modes. Some commands are built in. Some are bundled skills that appear in the same menu. The important part is not the label. The important part is that the command tells Claude what kind of work you want before the model starts improvising.
The commands worth learning first
The list below covers the commands I reach for most often in day-to-day use.
| Command | What it does | Why it matters |
|---|---|---|
| /clear | Clears the conversation history | Starts fresh when the session has too much stale context |
| /compact | Compresses the conversation with optional focus instructions | Keeps long sessions usable without losing the important thread |
| /config | Opens the settings interface | Lets you change model, theme, output style, and editor behavior |
| /model | Switches the active model | Useful when the task needs a different tradeoff between speed and depth |
| /permissions | Manages tool allow/ask/deny rules | Controls what Claude can do without asking again |
| /status | Opens a status view with session and account details | Fast way to check what Claude thinks is active right now |
| /help | Lists available commands | The quickest way to discover what your install exposes |
/clear
If a session has drifted too far, start over. A long chat can accumulate assumptions, dead ends, and partial context that no longer helps. /clear wipes that slate clean.
/clear
Use it when you switch from one task to another and do not want the old task bleeding into the new one.
/compact
When a session is still useful but too large, compact it instead of throwing it away. That keeps the current thread while trimming the cost of carrying every detail forward.
/compact focus on the auth flow and recent deployment failures
That focus text matters. It tells Claude what to preserve during the summary and what to de-emphasize.
/config
/config is the command I use when the environment itself needs to change. Maybe the current model is too slow, maybe the editor mode is wrong for how you type, or maybe the output style is not matching the task.
/config
It is a setup command, not a work command. That distinction is useful. You are adjusting the tool before continuing the task.
/model and /permissions
Different jobs want different models. A quick file rename does not need the same reasoning budget as a cross-file refactor or a root-cause investigation.
/model sonnet
Use it when the current session is right, but the model choice is wrong for the remaining work.
When Claude keeps asking permission for the same class of action, the session starts to feel slow. /permissions is the way to tune that boundary.
/permissions
That matters most when you are repeatedly reading files, running tests, or working in a project where the same safe action keeps getting interrupted.
Commands that fit real workflows
The commands above are the ones that shape the session. The next group shapes the work itself.
1 /diff
Review uncommitted changes or inspect what Claude changed in the current turn.
2 /resume
Continue an older session without rebuilding the entire context manually.
3 /init
Create a CLAUDE.md guide and initialize project context.
4 /debug
Turn on debug logging and inspect what went wrong in the current session.
5 /status
Check model, account, and connectivity state without leaving the session.
A practical example
If you are debugging a change and want to inspect the work before going any further, this is the kind of sequence that saves time:
/diff
/compact focus on the login regression
/status
First check the changes, then compress the conversation around the problem, then verify the current session state. It is a small loop, but it keeps the session disciplined.
The commands that save you from context bloat
The most common failure mode in Claude Code is not bad reasoning. It is too much context. A session that started clean can become noisy after enough file reads, edits, and side questions.
Bundled skills that behave like commands
Claude Code also ships bundled skills that appear in the same slash menu. These are not the same as the built-in commands above, but they are worth knowing because they feel like high-level shortcuts for specific jobs.
/simplify
/batch
/debug
/loop
The pattern is simple:
1 /simplify
Helps review recent changes for quality and reuse.
2 /batch
Useful when a large codebase change needs to be split into many units.
3 /debug
Turns on debugging support for the current session.
4 /loop
Re-runs a prompt on an interval for monitoring or babysitting a task.
When to use commands instead of plain prompts
Commands are best when the intent already has a known shape. If the task is "explain this error," a plain prompt may be enough. If the task is "clear the session, compact the history, inspect the diff, and continue from the latest checkpoint," commands are better.
The more repeatable the task, the more valuable the slash command becomes.
The most useful Claude Code slash commands are the ones that keep the session honest. /clear resets bad context. /compact preserves useful context without carrying everything. /config, /model, and /permissions adjust how Claude behaves. /diff, /resume, /init, and /debug keep day-to-day work moving.
If you learn only a handful, start with /clear, /compact, /diff, /resume, and /permissions. Those five cover the biggest sources of friction and give you the fastest return on time spent learning the interface.