Claude Code Slash Commands: The Ones That Actually Change How You Work

You use Claude Code every day. You open a session, explain your project, describe what you need, get good output, close the session. Tomorrow you do it again. From scratch.

Each session feels productive. You're getting work done. But zoom out and look at the pattern: you're spending five to ten minutes at the start of every session re-establishing context. Your project structure. Your preferences. Your tone of voice. The decisions you made last week that still apply today.

Run three or four sessions a day, and that's fifteen to forty minutes of pure repetition. Every day. Five days a week, that's roughly two to three hours gone. Over a year, you're looking at 100 to 150 hours of re-explaining things Claude already knew yesterday.

At your hourly rate... whether that's $100 or $200... that's $10,000 to $30,000 a year. Not on building. Not on shipping. On context recovery.

That's the Reset Tax. And most people don't see it because each individual session feels fine. The cost is invisible until you measure it.

I tracked my own sessions for a month. The context recovery time was worse than I expected... averaging 8 minutes per session, 4 sessions a day, 5 days a week. That's over 130 hours a year. For one person.

This isn't a prompting problem. It's an infrastructure problem. You're treating every conversation as disposable when the work you're doing is continuous.

Slash commands are how you fix that.

Type / inside Claude Code and a menu appears. There are roughly 55 built-in commands, plus custom ones you can create yourself. That sounds like a lot because it is. You don't need most of them.

Anthropic markets slash commands as convenient shortcuts. That's technically true and completely misleading. Shortcuts save you keystrokes. The commands that matter save you hours... because they change the structure of how Claude operates, not just what it outputs.

Slash commands aren't shortcuts for typing less. They're operator-level controls that change how Claude works. Three categories:

/init creates a file called CLAUDE.md in your project directory. This file is the first thing Claude reads when you start a session in that project. It's your project's memory.

What goes in it: your project structure, conventions, decisions you've made, things Claude should always know. “We use TypeScript. Tests go in __tests__. Don't add comments unless the logic isn't obvious. The API lives at /api/v2.”

The shift: instead of explaining your project every session, you explain it once. Claude starts every conversation already knowing the ground rules. That five to ten minutes of context-setting at the start of every session... gone.

Most people who try /init write a couple of lines and move on. The ones who get real value from it treat CLAUDE.md like a living document. Every time you catch yourself re-explaining something, add it to the file. Over weeks, it becomes a complete operating manual that makes Claude genuinely useful from the first message.

If CLAUDE.md is project memory, /memory is personal memory. It stores preferences that follow you across every project... your coding style, your communication preferences, how you like output formatted.

The distinction matters. CLAUDE.md says “this project uses Tailwind and deploys to Vercel.” /memory says “I prefer concise responses, I use VS Code, and I want you to explain your reasoning before making changes.”

CLAUDE.md lives in your project folder and can be shared with a team. Memory is personal and follows your account.

/permissions controls exactly what Claude can do on your system. Which files it can read, which commands it can run, what it needs to ask about first.

This isn't about fear. It's about trust with guardrails. You want Claude to edit files in your src/ directory without asking every time. You don't want it running rm -rf without a conversation first.

The default permissions work fine for most people. But if you're using Claude for anything serious... client work, production code, systems that handle real money... configuring permissions is how you go from “I hope it doesn't break anything” to “I know exactly what it can touch.”

Every conversation has a context window... the amount of information Claude can hold in its head at once. Long sessions fill it up. When it's full, Claude starts forgetting things from earlier in the conversation.

/context shows you a visual grid of what's using your context window right now. It's a diagnostic tool... you can see exactly how much space your conversation, your files, and your tools are consuming.

/compact reclaims that space. It compresses the conversation history, keeping the important parts and dropping the noise. Clearing your desk without throwing away your notes.

/compact isn't about saving tokens or reducing costs. It's about preserving what matters. A compact conversation where Claude remembers your key decisions is more useful than a bloated one where the important context is buried under 200 messages of back-and-forth.

When to use it: when your session starts feeling sluggish, when Claude starts forgetting decisions from earlier, or when you're about to start a new phase of work within the same session. You can even pass instructions: /compact focus on the database migration decisions to tell it what to prioritize.

/resume lets you pick up a previous session exactly where you left off. Not a new conversation about the same topic... the actual session, with all its context intact.

This changes the mental model completely. Sessions aren't disposable anymore. They're persistent workstreams you return to by name. You can /rename a session to “client-dashboard-rebuild” and come back to it three days later without losing a single decision.

The combination of /init (project memory) + /memory (personal preferences) + /resume (session persistence) is what eliminates the Reset Tax entirely. Claude remembers your project, remembers you, and remembers what you were working on. You open a session and start working. That's it.

/plan puts Claude into planning mode. Instead of immediately writing code or making changes, it reads the codebase, thinks through the approach, and presents a plan for your approval before touching anything.

Without /plan, you describe what you want, Claude starts building, and you course-correct along the way. With /plan, you align on the approach first, then execute. I started using /plan on anything that touches more than two files. The number of “wait, that's not what I meant” moments dropped to almost zero.

/ultraplan takes it further. It drafts the plan in a dedicated session, lets you review it in your browser, and then executes it... either remotely or in your terminal. The difference: /plan is thinking before doing. /ultraplan is architecture before building.

For anything that touches more than two or three files, or anything where the wrong approach would cost you an hour of undo work, planning first pays for itself immediately.

/rewind is version control for conversations. If Claude goes down the wrong path... wrong approach, wrong file, wrong assumption... you rewind to a checkpoint and try again. The code changes revert too.

This isn't undo. Undo removes the last action. /rewind takes you back to a specific point in the conversation with all the context intact up to that moment. You keep everything that was right and discard everything that went wrong.

The practical impact: you stop being afraid of letting Claude try ambitious approaches. If it doesn't work, you rewind. The cost of experimentation drops to near zero.

/diff opens an interactive viewer showing every change Claude has made... both uncommitted changes overall and what changed in each turn of the conversation.

Before you commit anything, you can see exactly what was modified. No surprises. No hunting through files to figure out what changed.

/batch is the scale command. It analyzes your codebase, breaks a large task into 5 to 30 independent units, spawns a separate agent for each one in isolated copies of your code, and each agent opens its own pull request when it's done.

One command. Parallel execution across your entire codebase. Each change isolated so nothing conflicts.

This is the command that turns “I need to rename this pattern across 40 files” from a full afternoon into 15 minutes. Or “update every API endpoint to the new authentication format” from a terrifying manual process into a reviewable set of pull requests.

If you work with code or manage a development team, this one matters. /autofix-pr watches your current pull request. When automated checks fail or a reviewer leaves a comment, Claude automatically pushes a fix.

The workflow shift: review stops being a back-and-forth where someone context-switches every time a flag goes up. Claude handles the mechanical fixes. Your team handles the judgment calls.

/voice enables push-to-talk voice dictation. Instead of typing your instructions, you talk. Claude transcribes and executes.

Some of the best work happens when you can think out loud instead of typing precisely. “Look at the user authentication flow, find where the session token gets created, and add logging so I can see what's happening when it expires”... that's easier to say than to type.

These four commands together mean your Claude session is infrastructure that follows you. Terminal to desktop. Desktop to web. Web to phone. Keyboard to voice. The session is the constant. The interface is interchangeable.

Everything above is built-in. The commands ship with Claude Code. But the real infrastructure play is building your own.

Custom skills are markdown files that live in .claude/skills/... either in your project directory (project-level) or in your home directory (personal, follows you everywhere). Each skill is a folder with a SKILL.md file that contains instructions Claude follows when you invoke it.

Here's what one looks like: