The argument in one line.
Claude Code's 20 slash commands manage context, permissions, memory, and model selection to solve the stateless nature of LLMs and reduce unnecessary token costs during development.
Read if. Skip if.
READ IF YOU ARE…
- You're new to Claude Code and have it installed but haven't yet explored what each of the 20+ slash commands actually do or when to use them.
- A developer who uses Claude Code regularly but treats commands like /clear, /memory, and /permissions as mysteries and wants to understand their mechanics and token implications.
- You're building a project in Claude Code and need to know how to structure conversations, manage context efficiently, and set up permissions or custom instructions without trial-and-error.
SKIP IF…
- You're already fluent in Claude Code commands and have internalized token economics — this is a command-by-command reference for people starting from scratch.
- You use Claude Code exclusively for simple one-off tasks and don't manage multi-turn conversations, custom instructions, or permission rules.
The full version, fast.
Claude Code ships twenty built-in slash commands, and knowing which ones matter is the difference between burning tokens and shipping focused work. Because LLMs are stateless, every follow-up message resends the entire chat history, so /clear should be run after each finished task to stop token costs from compounding, and /compact summarizes the conversation into a fresh window with optional custom instructions. /init scans your codebase and writes a CLAUDE.md that simulates persistent memory across sessions, while /memory layers project-wide rules with global user preferences and supports @-imports plus a # shortcut for quick adds. /permissions removes friction by allow-listing bash, read/edit, web fetch, and MCP rules with wildcards, but only allow tools you fully understand.
Free for members
Chat with this breakdown — free.
Sign in and you get 23 free chat messages on us — ask for the hook, quote a framework, find the exact transcript moment, generate a markdown action plan. Bring your own key when you want unlimited.
Create a free account →Where the time goes.
00:00 – 01:07
01 · Intro + /bug
Promise stated. /bug: report directly to Anthropic; GitHub issues page shown with 1.5k open issues.
01:07 – 04:01
02 · /clear
Token cost compounding explained: message 2 costs 1500 tokens not 500. Live /clear demo shows context wiped.
04:01 – 06:50
03 · /compact
Auto-compact at 95% capacity. Custom summarization instructions demo. Ctrl+R to inspect summary.
06:50 – 11:56
04 · /config
All 6 settings: auto-compact, use-todo, verbose, theme, notifications, editor mode, model selector.
11:56 – 12:25
05 · /cost
API-only usage tracker. No output on Max/Pro plans.
12:25 – 12:49
06 · /doctor
npm permissions health check.
12:49 – 13:13
07 · /help
Full inline command list.
13:13 – 15:50
08 · /init
Scans codebase, generates CLAUDE.md. Acts as persistent project memory.
15:50 – 16:11
09 · /login
Two methods: subscription (Pro/Max) vs API (Console).
16:11 – 16:36
10 · /logout
Prints session summary: total cost, duration, model breakdown.
16:36 – 19:03
11 · /mcp
MCP as translator/interface layer. Postgres example. Anthropic docs walkthrough. No install demo.
19:03 – 27:00
12 · /memory
Three memory types (project, user, project-local deprecated). @-import syntax. # shortcut. Best practices: specific, structured, lean.
27:00 – 28:22
13 · /model
Default routing: Opus 4 until 20% session limit, then Sonnet 4. How to pin a specific model ID.
28:22 – 34:17
14 · /permissions
Four rule types: bash (exact + wildcard), read/edit, web fetch, MCP. Allow/deny/workspace tabs. Safety warning.
34:17 – 35:48
15 · /pr_comments /review /status /terminal-setup /vim + Outro
Rapid-fire final commands. /status shows account/memory/model. Comment CTA.
Lines worth screenshotting.
- The /clear command is the most important command in Claude Code — every follow-up message resends the entire conversation history, so clearing frequently prevents exponential token cost growth.
- Message two in a conversation does not cost the tokens of message two alone — it costs message one plus message two because the model is stateless and reprocesses the full history each time.
- The /compact command summarizes the conversation and starts fresh with that summary, preserving essential context while eliminating the token overhead of the full raw history.
- Custom compaction instructions — summarize only the last conversation, keep it under 500 words — let you control exactly what survives the compaction rather than accepting Claude's default.
- Claude Code auto-compacts at 95% context capacity, which is a safety net, not a strategy — proactive compaction with targeted instructions is consistently better than the auto-triggered version.
- The /memory command manages three types of memory: project-level, user-level, and global — each with different scope and lifetime relative to sessions and projects.
- The @ import syntax inside CLAUDE.md lets you pull external files into the memory context without embedding their contents directly, keeping the main file clean and composable.
- The /permissions command supports four rule types with wildcards, giving fine-grained control over what Claude Code is allowed to read, write, or execute on the file system.
- Finishing a task and immediately running /clear is the highest-leverage habit for reducing token costs — unrelated tasks accumulating in the same window is the primary source of expensive context.
- The /config command controls auto-compact behavior, which by default triggers at 95% — turning it off in favor of manual compaction with custom instructions gives more consistent results.
- The # shortcut for adding to memory mid-conversation lets you capture an important decision or preference without interrupting the flow of the current task.
- Understanding token compounding makes /clear feel urgent rather than optional — a 10-message conversation can cost five times what 10 separate single-message conversations would cost.
Own your Claude Code workflow from day one.
Claude Code operator playbook
The commands most beginners never find - /compact with custom instructions, /memory @-import, and wildcard permissions - separate someone who fights Claude from someone who flows with it.
- Run /clear after every discrete task, not just when you hit the limit. Treat it like closing a browser tab.
- Use /compact with a specific instruction (summarize only the last task) rather than dumping the whole conversation.
- Build your CLAUDE.md with @-imports for modular instruction files - coding standards, commit message rules - keeps the root file lean.
- Use the # shortcut at the Claude prompt to add memories on the fly without opening the file.
- Set bash permissions for your most-used commands (npm run dev, npm run build) so you stop approving the same actions every session.
- The /logout session summary is your usage receipt - check it when debugging cost or model behavior.
Terms worth knowing.
- Claude Code
- Anthropic's command-line AI coding assistant that runs in a terminal and can autonomously read, edit, and run code files based on natural-language instructions.
- slash commands
- Special commands in Claude Code prefixed with a forward slash (e.g., /clear, /compact) that trigger built-in functions like clearing context, compacting conversation history, or managing settings.
- token
- The basic unit of text that language models process — roughly 3-4 characters or about 0.75 words — used to measure both the input sent to the AI and the output it generates, with cost billed per token.
- stateless (LLM)
- The property of large language models where each response is generated by reprocessing the entire conversation history from scratch — the model has no persistent memory between messages.
- context window
- The maximum amount of text a language model can process in one session — as a conversation grows longer, token costs compound because all prior messages are resent with each new message.
- /clear command
- A Claude Code command that wipes the entire current conversation history and starts a fresh session, stopping token costs from compounding across a long chat.
- /compact command
- A Claude Code command that compresses a long conversation into a concise summary, preserving essential context while reducing token count for the remainder of the session.
- /memory command
- A Claude Code command for managing persistent memory files that Claude can read across sessions — spanning project-level, global, and imported memories.
- @-import
- A syntax in Claude Code memory files that includes the content of another file by reference, allowing modular memory structures where one file pulls in another.
- /permissions command
- A Claude Code command for configuring which file paths and shell commands the AI is allowed to access or run, using wildcard rules to define security boundaries for autonomous operation.
- FastAPI
- A Python web framework for building APIs quickly, used here as the example codebase on which Claude Code commands are demonstrated.
Things they pointed at.
Lines you could clip.
01:24
“Message two actually costs a thousand five hundred tokens.”
03:27
“A good rule of thumb is to run it whenever you finish a task.”
27:46
“I have seen users with thousands of memory entries, and that usually ends up confusing both the user and the model.”
33:46
“Be very careful with permissions. Do not just copy someone elses permission rules unless you understand exactly what each command does.”
Word for word.
Read-along
Don't just watch it. Burn it in.
See every word as it's spoken — crank it to 2× and still catch all of it. The same dual-channel trick behind Amazon's Kindle + Audible.
00:00Hey, everyone. If you're new to Cloud Code, you might feel overwhelmed by all the commands available and wonder what they all do. So in this video, I'll walk you through all the commands that Cloud Code has and show you what they do and how to use them effectively.
00:14I'm going to assume you already have ClawdCode installed. Let's get started. The first command is the bug command.
00:21Since ClawdCode is still a relatively new tool, the team at Anthropic is actively building and improving it. And like any evolving product, that means bugs can pop up. If you come across a bug while coding, you can use the slash bug command to report it directly to the team.
00:38It's a simple way to contribute and just improve the platform. What's really cool is that Anthropic also maintains a public GitHub page for Claude code, and this is a page where you can see all the current issues that are being tracked as well as feature request and any bugs. It's very active, and you'll often see the actual Cloud Code developers engaging with users here, talking through issues, bugs, and features.
01:01So if you're interested in the development of Cloud Code, this is a great place to get involved in. Next up is the clear command, and it's probably the most important command in Claude code. So if there's one command to know, it's this one.
01:15What clear does is that it clears out your entire current chat conversation, all the context, and starts a brand new conversation. So why is this such a big deal?
01:26It's because large language models are stateless. That means they don't actually remember past messages between chats. Instead, every time you send a message in the same conversation window, Claude reprocesses the entire conversation history to understand the context.
01:43So let's just break this down with a simplified example. Let's say you send message one, which costs a thousand tokens, then you send message two, which on its own costs 500 tokens. You would think message two would only cost 500 tokens, but that's not how it works.
01:58Because LLMs are stateless, the model doesn't remember anything you sent in message one. And because you are still in the same chat window, the model assumes that every message you sent before is still relevant.
02:11So what the model will do is that it will send all of message one again plus message two. So in reality, message two actually costs a thousand 500 tokens. So if you send message three, the actual token cost is going to be message one plus message two plus message three.
02:29So you can see that with every follow-up message you send within the same chat window, each message is going to cost more and more tokens, which means if you have the super long chat windows with Claude, you will quickly use up all your tokens, and that's where this clear command comes in. So in this example, I have a long conversation going on.
02:51It's just pages and pages and pages. So every new message you send in here is also gonna send all of this as part of the input, and you don't want that. So when you run slash clear, what this is going to do is that it's gonna clear up all this context and start a brand new chat.
03:09So now you can see that once I ran it, there's no more context. Right? So if I scroll up, there's nothing left.
03:14All that context has been cleared up, and now we have a brand new chat. So now your next message you send will be sent without the entire previous context, and this helps reduce unnecessary token usage.
03:27So when should you use this clear command? You want to use this command as often as possible. A good rule of thumb is to run it whenever you finish a task.
03:36You don't want multiple unrelated tasks piling up in the same chat because that's just gonna blow it up your token count and make responses less focused. And just a quick note, this is a simplified example, and I do have a video that goes into more depth on how to optimize your token usage and how Cloudco calculates all of it.
03:57So if you're interested, go check it out. I'll link it in the description below. Next up is the compact command.
04:04The compact command is one of ClaudeCode's tools for managing token usage, similar to clear but with a different approach.
04:12While clear wipes out your chat history completely and starts from scratch, compact helps you reduce token usage by summarizing your conversation and starting a new chat with that summary. It's a way to keep important context without carrying every message forward. And this is how it works.
04:29When you run slash compact, Claude takes your entire current conversation and creates a summary of it and starts a new chat window with that summary preloaded. Now by default, if you were just to run slash compact, what this is gonna do is it's going to create a summary of your entire conversation.
04:49So everything you have in your current conversation, it's gonna take that entire thing and summarize it. And just another thing to note here, when Claude code reaches 95% capacity, so when this thing right here says there's only 5% left, it's going to auto compact your conversation.
05:06So this is Claude code's way to help you out. Now this default way of compacting is fine in many cases, but sometimes it's not what you want. You can actually customize what Claude summarizes by adding specific instructions.
05:20So for example, if I was just to do slash compact, you can see that I have this optional custom summarization instruction.
05:26So I can say things like summarize just the to do items, and this will summarize all the to do items I have within my current conversation.
05:35And I can maybe say summarize only the last conversation because maybe that's the only thing that's relevant.
05:43So Claude code is just gonna go through here, find my last conversation, and just summarize it. Or I can say something like, keep the summary to a max of 500 words or something, and this is gonna further limit what Claude code summarizes. So there's a lot of different ways to provide what summary you want to Claude.
06:00So let's just say for this example, I just wanna say summarize the last conversation. So what this is gonna do is Claude's gonna read my last conversation, provide a summary of it, open it up, and then preload it.
06:13So just give it a few seconds, and let's see what happens. Okay. So it looks like Claude code has finished summarizing my conversation.
06:19And you can see right here, this is that summary. So this is my previous conversation compacted. Right?
06:25It read through a bunch stuff, and it provide a summary. So if I was just to hit control r, this will show me what it summarized. So this is the summary.
06:33So now when I continue this conversation, this is the only thing that's going to be part of my context. It's no longer going to be the entire previous conversation.
06:43And what's even better is I have a summary of my previous conversation so I can just quickly pick up where I left off. Next up is the config command. So this command lets you customize Claude code's behavior to fit how you like to work.
06:58Let's walk through each option and show you what it does. So let's go to Claude code and write slash config. And in here, this is where you will find all your settings.
07:07So the first item is this auto compact. This setting controls whether ClaudeCode will automatically compact your conversation once it reaches 95% capacity.
07:17So remember in the compact command that we saw previously, we had that little status indicator at the bottom. So when that status indicator reaches 5%, ClawdCode will auto compact, and this is the setting that determines if you want it on or off.
07:31Now I recommend you leaving this on so you don't have to worry about hitting your limit and having everything just break. Next up is the use to do setting. This is one of the key reasons ClaudeCode feels more focused and effective compared to other AI coding tools.
07:47When you ask ClaudeCode to build a new feature, ClaudeCode automatically creates a internal to do list and follows that list step by step.
07:56This helps it stay on track even as the task gets complex. This is important because LLMs tend to lose focus in long conversations.
08:06But with a to do list, Claude code keeps its objectives clear and avoids getting lost in the details. So I 100% recommend you keep this setting as true.
08:18So let me show you what I mean with this to do list. I'm just gonna exit out of here. I am in this anal fax directory, and I am just going to ask ClaudeCode to create a new feature to allow users to add multiple animals via a endpoint.
08:37So I'm just gonna let this run and show you that to do list. Okay. So now that it finished running, let me show you Claude Code's thinking process.
08:46So if I scroll to the top, this is the request that I ask Cloud Code to do just to create a new API endpoint. So this right here is a to do list that Cloud Code is creating internally. Now remember, I did not ask Cloud Code to create any to do list.
09:00This is simply something that Cloud Code has created internally. And this is just saying, hey. The first thing that we should do is explore the code base, then the second thing to do is design the new endpoints and so on and so on.
09:11So the first step is to explore the code base. So you can see here, it does that right here. Let's explore the code structure.
09:17Structure. So it goes through here. It reads a bunch of files.
09:20Right? So now that it finished reading, it finished that first item. So now it's gonna update that to do list.
09:26You can see in this update to do list, that first item is now complete. So what's the next step? Well, the next step is to design that new endpoint.
09:34Okay? So what is it gonna do? Well, I am going to create a new schema for it because that's designing it.
09:39Right? So now it is here, and this is gonna ask it to make some edits to the animal dot p y file that I have. So you can see that Claude code is following this to do list, and it's a really cool way for Claude code to keep focus on what it needs to do.
09:54So going back to the config, I 100% recommend you keep this as true.
10:01Next is the verbose output. If you enable this, it's going to show you all of Claude's thinking process, like what files it's searching through, what functions it's reading, and so on. This is great if you are someone who wants full visibility into the model's decision making.
10:18But a heads up, if you enable this, it will literally output you the entire file's content in your chat window. So if your file content is a thousand lines of code, it is literally gonna print out a thousand lines of code for you. So what I recommend you do is to keep the setting as false, which is the default setting.
10:36And if you need to dig into its thinking process, you can actually click control r, and that will toggle the verbose view on and off whenever you need it. So the next one is theme. This one is simple.
10:48Just choose between light mode or dark mode. So just click on it, and you can choose all the different types of modes you want. I'm just gonna keep mine on light mode.
10:55Next is notification. Just keep this as auto. Next is this editor mode so you have normal and Vim.
11:02If you know what Vim is and want to use Vim style key binding inside ClaudeCode, you can switch to Vim here. Otherwise, don't worry about it.
11:11And the last setting is model. This setting lets you choose which model ClaudeCode is going to use. So by default, ClaudeCode is going to use this setting, and that means that ClaudeCode is gonna use Opus four and automatically switch to Sonnet four when needed.
11:26But if you want, you can specify a model you want here manually. For example, if you want to only use Opus four, then just click on this. If you only wanna use Sonnet four, just click on this.
11:36So this is just a way to switch models. And just a note here, OPUS four is only available for max plan users. So if you are a pro plan user, you won't have this option, and the default option actually defaults to SONNET four.
11:50So let's just say I wanna use SONNET four. Hit this, and it's going back to SONNET. And that's it for the config command.
11:57The next command is the cost command. So this command shows you how much you have spent using Claude code, but this is only if you are using the API version. If you're on the Macs or the Pro plan, this command won't return any data since those plans don't track cost the same way.
12:14But if you're using the API version, if you just do slash cost, this is just gonna tell you how much you have used so far in your session. So it's a pretty good way just to keep track of all your cost. The next command is the doctor command, and it's a simple diagnostic tool.
12:30It checks whether your ClaudeCode installation is working properly. So if we type slash doctor, this is mostly just gonna tell us whether ClaudeCode has the necessary NPM permissions to function properly.
12:42This is just a quick way to confirm everything's configured correctly, especially if you are troubleshooting. The help command is exactly what it sounds like. So if we just do slash help, it gives you a full list of all the available commands in Claude code along with a short description of what each one does.
13:02So if you scroll up, we could kinda see that these are all the commands that are available to us along with description of what they do. And if you're just getting started, definitely make use of it. The init command is your project starting point in Claude code.
13:17When you run it, Claude scans your entire code base reading every single file and generates a file called Claude dot m d. So let's do that right now for the code base I'm in. So right now, I'm in Claude code, and I am in this animal fax directory.
13:32So let's just run slash init and see what happens. And this command is going to take a while because it's gonna read through every single file. Okay.
13:41So now that it finished, you can see that this is that file that it's going to generate for you. So let's just hit yes, and it's gonna create that clawed m p file. So just hit yes, and it's gonna write that file to your code base.
13:54Okay. So now that it finished, let me open up Versus Code, and this right here is that new file that just got created. And within this file, you will find a high level summary of your project.
14:05So what it does, how it's structured, key components, important functions, and so on. So if we look at this cloth.
14:12M d file that was created in my case, I can see that we have some stuff in terms of our development commands. We have stuff on our architecture overview, how the project is structured, what key components there are.
14:24So there's a lot of high level summary within this file, and it's very helpful for the user as well as clawed code. So this file essentially acts as a memory for your codebase.
14:36Now, by default, large language models like Claude are stateless, which means they don't remember anything from one chat to the next. Every new conversation starts with a blank slate unless you give it context.
14:49And that's where this Claw. Md file comes in. When you run slash init, ClawdCode builds this file as a persistent summary of your project.
14:59Then when you start a new conversation, Claude automatically reads this file first. That way, it already understands the context of your project before you ask it to do anything.
15:11So even though the model itself can't retain memory, this claw dot m d file gives it a way to simulate memory. And, yes, this is the same file used by the memory command, which we will cover in more details later. You should always run slash init when using clawed code on a project for the first time, and this is something Anthropic actually recommends you do.
15:35Also, keep in mind that you can edit the cloth. Md file manually if you ever want to clarify or update the summary as your codebase evolves. So this is just a text file, you can just write and add stuff as needed.
15:50The log in command is pretty straight straightforward. It lets you log in to Cloud Code. The one important thing to note here is that when you log in, there's two methods.
16:00You can either log in with the subscription plan, which is for those on the pro plan or the max plan, and there's also a login through the API plan. So just make sure you choose the correct one. The logout command is also pretty straightforward.
16:13It logs you out of clogged code. But here's a useful feature. When you log out of Claude code, it actually gives you a summary of your session so you can see how much that session cost, how long it ran for, and what type of models that session used.
16:29So it's a great way to track your usage and get a quick snapshot of what Claude did behind the scenes. The MCP command allows you to connect Claude code with external MCP servers. Now MCP stands for model context protocol, and at a high level, it's a protocol that standardizes how large language models like Claude interact with external tools, systems, and applications.
16:55Now this is a big topic and can get very technical, so in this video, I'll stick to a high level explanation of what MCP is and why it's useful. I won't cover how to install it or how to set up a MCP server here since it's a more involved process, and the installation differs depending on what servers you want installed.
17:16But don't worry. I'll have dedicated videos on SCP soon. The easiest way to understand MCP is through a example.
17:24So by default, LLMs like Claude only understand text, some images, and maybe PDFs. They can't directly interact with things like a Postgres database. So if you ask Claude, hey.
17:36What does database x y z do? It won't know how to access it. It won't know how to read the tables or even understand its structure.
17:44That's because LLMs can't natively connect to or operate external systems. They need everything in a textual format.
17:54So this is exactly where MCP comes in. A MCP server, for example, one built for Postgres, acts as a kind of translator or interface layer.
18:04It exposes the structure, functionality, and data of the database in a way that Claude can understand and interact with using natural language.
18:15So with a MCP connection, Claude can reason about, query, or even help modify things like a Postgres database because it now has a structured way to interact with through a MCP layer. So this is a powerful concept with a lot of potential and definitely something I will cover more deeply in future videos.
18:35But if you're interested, go to the site here and read through this page. It has a lot of good information on what MCP is, how to configure MCP servers, how to understand the different scoping levels for MCP servers, how to set up authentication.
18:52And even here, it has a example on how to connect to a Postgres MCP server. So there's a lot of information on this site, so definitely go here and give it a read if you're interested. The memory command builds directly on what we discussed earlier with the slash init command.
19:08To quickly recap, when you run slash init, Claude co scans your project and creates a file called Claude dot m d. So this is that file right here.
19:19This is that Claude dot m d file that is within my codebase called AnimalFacts. So this file acts as the memory of your codebase, storing a summary of your project structure, components, and key behaviors.
19:33Since Claude itself is stateless, meaning it doesn't retain memory between chats, this file gives it a persistent reusable context for future conversations.
19:44Now memory in Claude code is a deep topic and also very subjective. How you use it will vary depending on your workflow and preferences. So in this video, I'll just give you a high level overview of what memory is and how to use it.
19:59And in a future video, we'll deep dive into it further. Okay. So at a high level, ClaudeCode supports three types of memories.
20:08There's project memory, there's user memory, and then there's this project memory local. So just ignore this one for now because it's no longer being used. So we'll just focus on these two here.
20:19Now as a FYI, all the memory files that gets created are all named claw dot m d, so it can be a bit confusing. So the first one is this project memory.
20:30So this is the claw dot m d file that gets created in your current project directory when you run slash init. So this is that file right here. So this is the project that I have, and this is that file right there within the root folder.
20:43So when I run slash init, this is gonna get all populated, and it's just a summary of what this codebait does. So every time you work within this directory, Claude will reference this file for context.
20:56So in this file, this is where you can store things like a high level architectural description, which is what gets auto populated when you run slash init. You can also have things like coding standards specific to this project. So let's just say that here, I want to have a section for coding standards.
21:13So I can have this little section right here. So maybe for this project, I wanna use four spaces for indentation. I wanna have a max length of 80 characters.
21:22I wanna make sure that there's specific schemas for data models and so forth. So there's just a lot of things you could do here. You could have whatever coding standards you want.
21:31Now just keep in mind, this project memory should include things relevant to the whole code base. So the things you'll write here should not be specific to one file or subfolder.
21:43Okay. Now let's look at the second one, user memory. This is a global memory file, which means it applies across all your projects.
21:52So whatever project you do within Claude code, this user memory file will always be called. So let's see how we can actually create it. So let's just go into Claude code, and I'm just gonna write slash memory.
22:04And here, this is just gonna tell me what type of memories I So you can see here that I have one project memory, and it's that claw dot m d file that we looked at earlier. And here, we have the three levels of memory. So we have the project memory with the local one.
22:18Ignore this one, and then this is that user memory. So right now, we have zero memories in here. So if we click on this, this is gonna open up a new file, and this new file is the user memory file.
22:30This is where you wanna store personal preferences that apply across all your projects. So, for example, this is where you can have things like user preferences.
22:39For example, you want ClaudeCode to call you a certain name, you could put it here. If you want ClaudeCode to keep your responses short and concise, you could mention it here. And you can also have ClaudeCode avoid certain phrases.
22:51So with Sonnet four, it really likes to use phrases like you're absolutely correct and this is perfect. So if you don't like that, you could tell ClaudeCode to avoid that. You can tell Clarcode to always respond in markdown format, use bullet points instead of paragraphs.
23:06And for coding style preferences, you can say that you like to use snake case. You can tell Clarcode to avoid short variable names like x and temp.
23:15So there's a lot of things you can include in this user memory file, and the things I have here is just a quick example, and you can quickly adapt this to your own personal preferences. Okay. Now let's look at how to import custom files into memories.
23:30Okay. Now let's look at how to import custom files into memories. So with ClawdCode, they also give you the ability to import custom files that can act as your own memory.
23:42So let's go back to our code base memory file. So that's this one right here. So this is the ClawdCode to know that I want ClawdCode to know in in terms terms of how to write a git commit message.
24:05So instead of having all of this within here, I can write that instruction here. And then within this memory file here, I can simply just say, hey. Reference this file in this location.
24:17And ClaudeCode is smart enough to know that if it sees this at sign, it's going to look into this file and pull in the necessary information and make it as part of the memory. So the ability to import custom files into this memory file is very nice, and it just keeps your memory file short and organized. Okay.
24:37Now let's look at a quick way to add something to memory with the memory hashtag sign. So if I am in Claude code and I want to add something to memory directly without having to go to my Claude dot m d file, what I can do is I can just do hashtag, and this will tell me to add a memory.
24:55So let's say that I wanna add a memory of prefer map and filter over for loops.
25:02And if I hit enter, now this is gonna tell me where I wanna save it. So let's say that I wanna save this memory into our project memory.
25:10So let's just hit enter, and this is gonna save it into that memory. So now that it finished, let's go look at that memory. So if we open up our project memory.
25:19Right? So we are in our Claw dot m d within our animal facts file. This is that exact memory that we ask claud code to create for us, and it's stored right here.
25:27Okay. Now let's go look at some best practices when it comes to claud memories. So when it comes to best practices, you always wanna be specific, and that makes sense.
25:37You always wanna be as descriptive as possible. So you don't wanna have general instructions like use comments and functions. That's not very helpful.
25:46Instead, you want to say all functions must include a multiline comment with a short description, parameter list, dependencies, and return type. That is much more specific, and Clarica will have a better idea of what to do with it. And the second is you always want to use structure to organize.
26:03So that means you want to kinda format each individual memory as a bullet point within a group. So in my case here, I have a group for coding standards. I have a group for local development.
26:15So you just don't want to have these things scattered throughout the memory file. You wanna kinda put these into logical groupings. So memory is a very powerful tool, and it can easily get overwhelming.
26:28Now my personal recommendation is that if you are just starting with Claude code, don't worry too much about memory at first. So just use Claude code for a while and just see what type of patterns and preferences come up naturally, and then slowly start to add those to your memory over time.
26:46Also, another important thing to note here is do not go overboard. I have seen users with thousands of memory entries, and that usually ends up confusing both the user and the model. So keep your memory files lean.
27:00The model command lets you choose exactly which Claude model you want Claude code to use when processing your request. So if I go to slash model, by default, if you're on the max plan, Clogcode will use Opus four until you reach 20% of your session's usage limits, then it will switch to Sonnet four.
27:22If you're on the pro plan, it will just default to Sonnet four. Now if you don't like this default option, you can specify which model you want Claude Co. To use.
27:32So in this case, I can decide if I wanna use Opus four or Sonnet four. Now if you wanna use a model that's not Opus four or Sonnet four, for example, let's say you wanna use SONNET 3.7 or even 3.5, what you can do is you can go to this website here.
27:47So this is just Anthropix models website. So if you go here and scroll down, there is a list of all the models that Claude Co. Currently has.
27:56And let's just say that you want to use Claude Sonnet 3.5. So what you're gonna do is just copy this name here. Now it's important if you're using Claude Co.
28:04To copy the name from this column here. So copy from this first column. Copy this name, go back to here, exit out, and just write slash model, and then just paste in that name.
28:15And now if you hit enter, this is gonna set Claudcode to using that specific model. And that's it. The permissions command lets you control which tools ClaudeCode can and cannot automatically run-in your codebase.
28:29If you have used ClaudeCode before, you have probably run into this situation. Claw tries to run a command, then pauses to ask for your approval, runs a bit more, then stops again, waiting again for your approval for the next action, and so on and so on. So this is helpful for safety, but when it comes to development speed, it can really slow you down.
28:49That's where the permissions command comes in. Once you are comfortable with Claude's tools, you can specify which commands it's allowed to run without asking you and which one should still require manual approval.
29:02So code supports four types of permission rules. So Claude code supports four types of permission rules.
29:09You have bash, you have read and edit, you have web fetch, and then you have MCP. So let's break each one down.
29:17The first is the bash commands. So for those new to the terminal or Linux, which is what Mac is based off, so this also applies to Mac users as well, bash commands are terminal instructions like running scripts, searching and editing text files, installing packages, and so on.
29:35And when it comes to permissions for bash commands, you can allow specific bash commands using exact matches or wildcards. Okay.
29:43So now let's look at this in Claude code. So if I go to Claude code and write slash permissions, you can see that there's three tabs.
29:51I have the allow, I have the deny, and I have the workspace tab. So let's just say, for example, that you do a lot of Node.
29:58Js projects, and you want Cloud Code to always be able to run NPM run build without having you to always approve it in any projects. So if I go to this allowed tab and I hit enter on here so in here, if I write bash n p m run build, this is now going to let Cloud Code run this command without having you to ever approve it again.
30:22And another cool thing is that Cloud Code also supports wildcards for these bash commands. So let's take a look at this example right here. So for this example, I have n p m run test wildcard.
30:33So this is kinda saying that anytime Cloud Code encounters a command that starts with n p m run test, it will always approve it. So let's say that you have n p m run test coverage, that is going to be auto approved because you have this here. So that's the first type bash.
30:50Now let's look at the read and write. So these permissions control which files ClaudeCode can read and edit, and they also follow the git ignore filters if you're familiar with git. Okay.
31:01Let's go take a look at a example. So I'm just gonna open up Versus Code, and I have this hello dot p y file.
31:08Now, currently, if I go to Claude code and I just type out this statement of add a print dot hi statement to the holo dot py file, what's gonna happen is that Claude code is going to need my approval first before it can edit this file.
31:26So let's just give it a few seconds, and see right here, it's gonna ask me for approval to add this file. But let's say that I don't want this. I want ClawdCode to auto approve this.
31:35How can I do this? So to do that, let me just exit out of this. Let me just go to permissions.
31:39And in here, within my allowed tab, what I'm gonna do is I'm gonna add a new rule. So I'm gonna hit enter, and then here, I am going to add a rule of edit.
31:49Now remember, this is how it looks like. This is how it looks like for edit. So I'm gonna go to edit hello dot p y, and then just hit save, and I'm gonna save it into my project setting.
32:00Hit enter. And then now I have this new rule that allows me to edit into this hello dot p y file. So now I'm gonna exit out this, and what you need to do is you actually have to exit first in order for a ClawCode to refresh.
32:13So I'm gonna exit this, reenter ClawCode, and now I'm gonna ask that exact same command. So I'm gonna ask this exact same command and see what happens.
32:21Now hit enter, and then it says it's gonna add it. And then there, it's done. Now it says this file now contains that statement.
32:28So let's go take a look. If I open this file, and there it is. So that's the second type, read and edit.
32:34Now let's look at web fetch. So Cloud Code can also fetch information from the web, but normally, it'll ask you before doing so. So if you want Cloud Code to always be able to search a specific site, you can add a rule by first going to permissions again, going to allow, add a new rule, and here, I'm just gonna add a new rule of web fetch.
32:56And then here, just enter the website that I want. So I'm gonna say google.com. Hit enter, and just hit my project settings.
33:04And then now if I just refresh, let's exit this. Go Claude, and let's just say search Google to see what time it is in New York City.
33:16Hit enter, and then now it should be able to search Google without having me to approve. And there it is. It just says what time it is.
33:23Okay. Now let's look at MCP. So for MCP, these permissions control which server tools you can allow.
33:30So you can allow or restrict certain tools within a MCP server. So for example, here, this is saying that this allows you to use any tools within the Puppeteer server. But if you wanna get more specific, you can say to allow or deny a specific tool within that server, such as to navigate.
33:47Now if you wanna delete a rule, it's really simple. All you gotta do is go into your permissions, find the rule that you want, hit on it, and just say if you wanna delete it or not, and that's it.
33:58Now here's something important. Be very careful with permissions. Don't just copy someone else's permission rules unless you understand exactly what each command does.
34:08Allowing Claude code to automatically run tools, especially ones that create or edit files, can cause major problems if misused. The pr comments command lets you view the comments from a GitHub pull request inside Cloud Code. And the review command allows Cloud Code to review a GitHub pull request for you.
34:30So the status command shows your working directory. It shows what account you're logged into. So if you have the Max or Pro plan, make sure you are actually logged into that and not the API version.
34:42It also shows you what type of memories you currently have as well as which model you're using. So this is a great command just to kinda get a overview of your entire code base. The terminal setup command allows you to use the option plus enter keyboard shortcut to enter new lines.
34:58And for the VIM command, if you are a VIM user, this command will put clogged code into VIM mode, enabling VIM style keybinds. So if you're not familiar with VIM, don't worry about it.
35:10Personally, I don't use VIM, so I skipped this one. And that's it. This is a full overview of all the commands Claude code has to offer and how they work and how to use them effectively.
35:22I know this was a lot of information, and some topics like MCP go much deeper than what we covered here.
35:29But don't worry, I'll be making more videos on those topics soon. And I hope this was helpful and cleared up some confusions around some of the commands that Cloud Code has. If you have any questions or want me to cover something specific in a future video, feel free to drop a comment below.
35:45Thanks for watching. See you all in the next one.
The Hook
The bait, then the rug-pull.
Every beginner who opens Claude Code for the first time stares at a terminal prompt and thinks: what do I even type? This 35-minute encyclopedic walkthrough covers every slash command in docs order, live demo included. The promise is on the thumbnail before you click.
Named ideas worth stealing.
01:24concept
Token Cost Compounding
Every message re-sends all prior messages. Use /clear after each discrete task.
Steal forOnboarding explainer on why context management matters
20:04list
Three Memory Types
- Project memory (./CLAUDE.md)
- User memory (~/.claude/CLAUDE.md)
- Project-local (deprecated)
Project = codebase rules. User = personal preferences across all projects. @-import keeps CLAUDE.md lean.
Steal forJoeFlow CLAUDE.md setup
29:22list
Four Permission Rule Types
- Bash (exact match or wildcard)
- Read/Edit (gitignore-aware)
- WebFetch (domain)
- MCP (server or tool)
Granular control over what Claude auto-runs. Wildcards supported.
Steal forAny Claude Code workflow where approval prompts slow you down
How they asked for the click.
VERBAL ASK
35:22subscribe
“If you have any questions or want me to cover something specific in a future video, feel free to drop a comment below.”
Low-pressure soft CTA, comment solicitation only. Leaves viewer wanting the MCP and memory deep-dives promised.
MENTIONED ON CAMERA
FROM THE DESCRIPTION
OTHER LINKSAlso linked in the description.
Visual structure at a glance.
