00:02Hey everyone

00:04If you're new to Claude Code, you might feel overwhelmed by all the commands available and wonder what they all do

00:06So, in this video, I'll walk you through all the commands that Claude Code has and show you what they do and how to use them effectively

00:13I'm going to assume you already have Claude Code installed

00:15Let's get started

00:17The first command is the bug command

00:19Since Claude Code is still a relatively new tool, the team at Anthropic is actively building and improving it

00:26And like any evolving product, that means bugs can pop up

00:31If you come across a bug while coding, you can use the /bug command to report it directly to the team

00:36It's a simple way to contribute and just improve the platform

00:39What'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 requests and any bugs

00:53It's very active, and you'll often see the actual Claude Code developers engaging with users here, talking through issues, bugs, and features

00:58So, if you're interested in the development of Claude Code, this is a great place to get involved in

01:07Next up is the clear command, and it's probably the most important command in Claude Code

01:12So, if there's one command to know, it's this one

01:14What clear does is that it clears out your entire current chat conversation, all the context, and starts a brand new conversation

01:23So, why is this such a big deal? It's because large language models are stateless

01:28That means they don't actually remember past messages between chats

01:32Instead, every time you send a message in the same conversation window, Claude reprocesses the entire conversation history to understand the context

01:42So, let's just break this down with a simplified example

01:44Let's say you send message one, which costs 1,000 tokens

01:48Then you send message two, which on its own costs 500 tokens

01:51You 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:10So what the model will do is that it will send all of message one again plus message two

02:18So in reality, message two actually costs 1,500 tokens

02:20So if you send message three, the actual token cost is going to be message one plus message two plus message three

02:28So 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 these super long chat windows with Claude, you will quickly use up all your tokens

02:42And that's where this clear command comes in

02:46So in this example, I have a long conversation going on

02:50It's just pages and pages and pages

02:52So every new message you send in here is also going to send all of this

02:57as part of the input, and you don't want that

03:00So when you run /clear, what this is going to do is that it's going to clear up all this context and start a brand new chat

03:07So 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:13All that context has been cleared up, and now we have a brand new chat

03:16So now your next message you send will be sent without the entire previous context, and this helps reduce unnecessary token usage

03:26So when should you use this clear command? You want to use this command as often as possible

03:31A good rule of thumb is to run it whenever you finish a task

03:37You don't want multiple unrelated tasks piling up in the same chat because that's just going to blow it up

03:41your token count and make responses less focused

03:45And 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 Claude Code calculates all of it

03:55So, if you're interested, go check it out

03:57I'll link it in the description below

04:00Next up is the compact command

04:03The compact command is one of Claude Code's tools for managing token usage

04:07Similar 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

04:23It's a way to keep important context without carrying every message

04:25forward

04:29And this is how it works

04:33When 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

04:37Now, by default, if you were just to run /compact, what this is going to do is it's going to create a summary of your entire conversation

04:47So, everything you have in your current conversation, it's going to take that entire thing and summarize it

04:53And 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:04So this is Claude Code's way to help you out

05:09Now, this default way of compacting is fine in many cases, but Sometimes it's not what you want

05:14You can actually customize what Claude summarizes by adding specific instructions

05:18So, for example, if I was just to do /compact, you can see that I have this optional custom summarization instructions

05:25So, 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:42So, Claude Code is just going to go through here, find my last conversation, and just summarize it

05:45Or I can say something like, "Keep the summary to a max of 500 words," or something

05:53And this is going to further limit what Claude Code summarizes

05:55So 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 want to say, "Summarize the last conversation." So what this is going to do is Claude's going to read my last conversation, provide a summary of it, open it up, and then preload it

06:11So just give it a few seconds and let's see what happens

06:15Okay, so it looks like Claude Code has finished summarizing my conversation

06:19And you can see right here, this is that summary

06:20So this is my previous conversation compacted, right? It read through a bunch of stuff and it provided a summary

06:26So if I was just to hit Ctrl R, this will show me what it summarized

06:31So this is the summary

06:33So now when I continue this, conversation

06:35This is the only thing that's going to be part of my context

06:39It's no longer going to be the entire previous conversation

06:42And what's even better is I have a summary of my previous conversation, so I can just quickly pick up where I left off

06:47Next up is the config command

06:53So 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

07:00So let's go to Claude Code and write /config

07:02And in here, this is where you will find all your settings

07:06So the first item is this autocompact

07:08This setting controls whether Claude Code will automatically compact your conversation once it reaches 95% capacity

07:15So remember in the compact command

07:18that we saw previously, we had that little status indicator at the bottom

07:23So when that status indicator reaches 5%, Claude Code will auto-compact

07:27And this is the setting that determines if you want it on or off

07:30Now, I recommend you leaving this on so you don't have to worry about hitting your limit and having everything just break

07:37Next up is the use to-do setting

07:40This is one of the key reasons Claude Code feels more focused and effective compared to other AI coding tools

07:45When you ask Claude Code to build a new feature, Claude Code automatically creates an internal to-do list and follows that list step by step

07:54This helps it stay on track even as the task gets complex

07:59This is important because LLMs tend to lose focus in long conversations, but with a to-do list, Claude Code keeps its objectives clear and avoids getting lost in the details

08:13So, I 100% recommend you keep the setting as true

08:16So, let me show you what I mean with this to-do list

08:18I'm just going to exit out of here

08:20I am in this Anoax directory and I am just going to ask Claude Code to create a new feature to allow users to add multiple animals via an endpoint

08:37So I'm just going to let this run and show you that to-do list

08:38Okay, so now that it finished running, let me show you Claude Code's thinking process

08:43So if I scroll to the top, this is the request that I asked Claude Code to do, just to create a new API endpoint

08:50So this right here is a to-do list that Claude Code is creating

08:53internally

08:56Now remember, I did not ask Claude Code to create any to-do list

08:59This is simply something that Claude Code has created internally

09:03And this is just saying, hey, the first thing that we should do is explore the codebase

09:06Then the second thing to do is design the new endpoints and so on and so on

09:10So the first step is to explore the codebase

09:12So you can see here it does that right here

09:14Let's explore the code structure

09:16So it goes through here, it reads a bunch of files, right? So now that it finished reading, it finished that first item

09:22So now it's going to update that to-do list

09:24You can see in this update to-do list, that first item is now complete

09:28So what's the next step? Well, the next step is to design that new

09:33endpoint

09:39Okay, so what is it going to do? Well, I am going to create a new schema for it, cuz that's designing it, right? So now it is here, and this is going to ask it to make some edits to the animal.py file that I have

09:45So 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:52So, going back to the config, I 100% recommend you keep this as true

09:59Next is the verbose output

10:02If 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

10:12This is great if you are someone who wants full visibility into the model's decision-making

10:16But, a heads up, if you enable this, it will literally output you the entire file's content in your chat window

10:23So, if your file content is a thousand lines of code, it is literally going to print out a thousand lines of code for you

10:30So, 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 Ctrl+R, and that will toggle the verbose view on and off whenever you need it

10:44So, the next one is theme

10:46This one is simple

10:48Just choose between light mode or dark mode

10:50So, just click on it, you can choose all the different types of modes you want

10:53I'm just going to keep mine on light mode

10:54Next is notification

10:56Just keep this as auto

10:57Next is this editor mode

11:00So, you have normal and vim

11:04If you know what Vim is and want to use Vim-style key bindings inside Claude Code, you can switch to Vim here

11:07Otherwise, don't worry about it

11:09And the last setting is model

11:11This setting lets you choose which model Claude Code is going to use

11:16So by default, Claude Code is going to use this setting, and that means that Claude Code is going to use Opus 4 and automatically switch to Sonnet 4 when needed

11:25But if you want, you can specify a model you want here manually

11:29For example, if you want to only use Opus 4, then just click on this

11:33If you only want to use Sonnet 4, just click on this

11:36So this is just a way to switch models

11:37And just a note here, Opus 4 is only available for max plan users

11:42So if you're a pro plan user, you won't have this

11:44option

11:47And the default option actually defaults to Sonnet 4

11:49So let's just say I want to use Sonnet 4

11:51Hit this, and it's going back to Sonnet

11:52And that's it for the config command

11:56The next command is the cost command

11:59So this command shows you how much you have spent using Claude Code

12:02But this is only if you are using the API version

12:06If you're on the max or the pro plan, this command won't return any data since those plans don't track cost the same way

12:13But if you're using the API version, if you just do /cost, this is just going to tell you how much you have used so far in your session

12:19So it's a pretty good way just to keep track of all your cost

12:23The next command is the doctor command, and it's a simple diagnostic tool

12:28It checks whether your cloud code installation is working properly

12:33So if we type `/docctor`, this is mostly just going to tell us whether clawed code has the necessary npm permissions to function properly

12:40This is just a quick way to confirm everything's configured correctly, especially if you are troubleshooting

12:48The help command is exactly what it sounds like

12:51So if we just do `/help`, it gives you a full list of all the available commands in clawed code along with a short description of what each one does

13:01So if we scroll up, we can kind of see that these are all the commands that are available to us along with a short description of what they do

13:09And if you're just getting started, definitely make use of it

13:11The init command is your project starting point in Claude Code

13:16When you run it, Claude scans your entire codebase, reading every single file and generates a file called claw.md

13:24So let's do that right now for the codebase I'm in

13:26So right now I'm in claw code and I am in this animal fax directory

13:31So let's just run /init and see what happens

13:33And this command is going to take a while because it's going to read through every single file

13:41Okay, so now that it finished, you can see that this is that file that it's going to generate for you

13:45So let's just hit yes and it's going to create that claw tomb file

13:48So just hit yes and it's going to write that file to your codebase

13:52Okay, so now that it finished, let me open up VS Code, and this right here is that

13:58new file that just got created

14:00And within this file, you will find a high-level summary of your project

14:04So what it does, how it's structured, key components, important functions, and so on

14:09So if we look at this cloud MD 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 Claude Code

14:29So this file essentially acts as a memory for your codebase

14:35Now, 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 Claude MD file comes in

14:51When you run `/init`, Claude Code builds this file as a persistent summary of your project

14:57Then, when you start a new conversation, Claude automatically reads this file first

15:04That way, it already understands the context of your project before you ask it to do anything

15:09So, even though the model itself can't retain memory, this Claude.md file gives it a way to simulate memory

15:18And yes, this is the same file used by the memory command, which we will cover in more detail later

15:25You should always run `/init` when using Claude Code on a project for the first time

15:31And this is something Anthropic actually recommends you do

15:35Also, keep in mind that you can edit the Claude MD file manually if you ever want to clarify or update the summary as your codebase evolves

15:43So, this is just a text file, so you can just write and add stuff as needed

15:50The login command is pretty straightforward

15:52It lets you log into Claude Code

15:54The one important thing to note here is that when you log in, there are two methods

15:59You 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

16:07So, just make sure you choose the correct one

16:09The logout command is also pretty straightforward

16:11It logs you out of Claude Code

16:13But here's a useful feature

16:15When you log out of Claude Code, it actually gives you a summary of your session

16:21So, you can see how much that session cost, how long it ran for, and what type of models that session used

16:28So, it's a great way to track your usage and get a quick snapshot of what Claude did behind the scenes

16:34The MCP command allows you to connect Claude code with external MCP servers

16:41Now, 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:54Now, this is a big topic and can get very technical

16:56So, in this video, I'll stick to a high-level explanation of what MCP is and why it's useful

17:04I won't cover how to install it or how to set up an MCP server

17:07Here, since it's a more involved process, and the installation differs depending on what servers you want installed

17:14But don't worry, I'll have dedicated videos on MCP soon

17:19The easiest way to understand MCP is through an example

17:22So, by default, LLMs like Claude only understand text, some images, and maybe PDFs

17:29They can't directly interact with things like a Postgress database

17:34So, if you ask Claude, "Hey, what does database XYZ do?" it won't know how to access it

17:39It won't know how to read the tables or even understand its structure

17:43That's because LLMs can't natively connect to or operate external systems

17:49They need everything in a textual format

17:51So, this is exactly where MCP comes in

17:54An MCP server, for example, one built For Postgres, it acts as a kind of translator or interface layer

18:03It exposes the structure, functionality, and data of the database in a way that Claude can understand and interact with using natural language

18:13So, with an 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 it through an MCP layer

18:26So, this is a powerful concept with a lot of potential, and definitely something I will cover more deeply in future videos

18:33But if you're interested, go to the site here and read through this page

18:38It 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, and even here, it has an example on how to connect to a Postgres MCP server

18:55So, there's a lot of information on this website

18:59So, definitely go here and give it a read if you're interested

19:00The memory command builds directly on what we discussed earlier with the /init command

19:08To quickly recap, when you run slash init, Claude scans your project and creates a file called claw.md

19:13So, this is that file right here

19:17This is that claw.md file that is within my codebase called animal factax

19:22So, 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:41Now, memory in Claude Code is a deep topic and also very subjective

19:47How you use it will vary depending on your workflow and preferences

19:53So, in this video, I'll just give you a high-level overview of what memory is and how to use it, and in a future video, we'll deep dive into it further

19:58Okay

20:03So at a high level, Claude Code supports three types of memories

20:08There's project memory, there's user memory, and then there's this project memory local

20:12So just ignore this one for now because it's no longer being used

20:16So we'll just focus on these two here

20:19Now, as an FYI, all the memory files that get created are all named Claude.md, so it can be a bit confusing

20:26So the first one is this project memory

20:28So this is the claw.md file that gets created in your current project directory when you run /init

20:35So this is that file right here

20:37So this is the project that I have, and this is that file right there within the root folder

20:43So when I run /init, this is going to get all populated, and it's just a summary of what this codebait does

20:48So every time you work within this directory, Claude will reference this file for context

20:54So 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 /init

21:03You can also have things like coding standards specific to this project

21:08So let's just say that here I want to have a section for coding standards

21:12So I can have this little section right here

21:14So maybe for this project, I want to use four spaces for indentation

21:18I want to have a max length of 80 characters

21:20I want to make sure that there are specific schemas for data models and so forth

21:25So there's just a lot of things you could do here

21:27You could have whatever coding standards you want

21:30Now, just keep in mind, this project memory should include things relevant to the whole codebase

21:36So the things you write here should not be specific to one file or subfolder

21:39Okay

21:42Now let's look at the second one, user memory

21:45This is a global memory file, which means it applies across all your projects

21:51So whatever project you do within Claude Code, this user memory file will always be called

21:56So let's see how we can actually create it

21:58So let's just go into cloud code and I'm just going to write /memory

22:02And here, this is just going to tell me what type of memories I have

22:06So you can see here that I have one project memory, and it's that claw.md file that we looked at earlier

22:13And here we have the three levels of memory

22:15So we have the project memory, we have the local one

22:16Ignore this one

22:18And then this is that user memory

22:20So right now, we have zero memories in here

22:22So if we click on this, this is going to open up a new file

22:26And this new file is the user memory file

22:29This is where you want to store personal preferences that apply across all your projects

22:33So, for example, this is where you can have things like user preferences

22:38For example, you want Claude Code to call you a certain name, you could put it here

22:42If you want Claude Code to keep your responses short and concise, you can mention it here

22:45And you could also have Claude Code avoid certain phrases

22:49So with Sonnet 4, it really likes to use phrases like, "You're absolutely correct," and this is perfect

22:56So if you don't like that, you could tell Claude Code to avoid that

22:59You can tell Claude Code to always respond in markdown format, use bullet points instead of paragraphs

23:05And for coding style preferences, you can say that you like to use snake case

23:09You can tell Claude Code to avoid short variable names like X and temp

23:14So there's a lot of things you can include in this user memory file

23:18And the things I have here is just a quick example, and you can quickly adapt this to your own personal preferences

23:22Okay

23:25Now let's look at how to import custom files into memories

23:28Okay

23:31Now let's look at how to import custom files into memories

23:34So with Claude Code, they also give you the ability to import custom files that can act as your own memory

23:41So let's go back to our codebase memory file

23:44So that's this one right here

23:46So this is the Claude MD file within my codebase

23:48So here I have this line right here where I say reference at getit instructions.md

23:53So if I open up this file, this is the one right here

23:56I have some custom instructions that I want Claude Code to know in terms of how to Write a get commit message

24:03So 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:15And Claude Code 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

24:28So the ability to import custom files into this memory file is very nice, and it just keeps your memory file short and organized

24:36Okay, now let's look at a quick way to add something to memory with the memory hashtag sign

24:41So if I am in Claude Code and I want to add something to memory directly without having to go to my claw.md file, what I can do is I can Just do hashtag, and this will tell me to add a memory

24:53So let's say that I want to add a memory of prefer map and filter over for loops

24:59And if I hit enter now, this is going to tell me where I want to save it

25:05So let's say that I want to save this memory into our project memory

25:09So let's just hit enter, and this is going to save it into that memory

25:13So now that it finished, let's go look at that memory

25:15So if we open up our project memory, right? So we are in our claw.md within our animalax file

25:22This is that exact memory that we asked Claude Code to create for us, and it's stored right here

25:25Okay

25:28Now let's go look at some best practices when it comes to Claude memories

25:30So when it comes to best practices, you always want to be specific

25:35And That makes sense

25:37You always want to be as descriptive as possible

25:40So you don't want to have general instructions like, "Use comments in functions." That's not very helpful

25:46Instead, you want to say, "All functions must include a multi-line comment with a short description, parameter list, dependencies, and return type." That is much more specific, and Claude will have a better idea of what to do with it

25:57And the second is, you always want to use structure to organize

26:02So that means you want to kind of format each individual memory as a bullet point within a group

26:09So in my case here, I have a group for coding standards, I have a group for local development

26:13So you just don't want to have these things scattered throughout the memory file

26:17You want to kind of put these into logical groupings

26:20So, 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

26:34So, 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 into your memory over time

26:44Also, another important thing to note here is, do not go overboard

26:49I have seen users with thousands of memory entries, and that usually ends up confusing both the user and the model

26:56So, keep your memory files lean

26:59The model command lets you choose exactly which Claude model you want Claude Code to use

27:05When processing your request

27:07So if I go to /model, by default, if you're on the max plan, Claude Code will use Opus 4 until you reach 20% of your sessions usage limits

27:13Then it will switch to Sonnet 4

27:18If you're on the pro plan, it will just default to Sonnet 4

27:24Now, if you don't like this default option, you can specify which model you want Claude Code to use

27:31So, in this case, I can decide if I want to use Opus 4 or Sonnet 4

27:36Now, if you want to use a model that's not Opus 4 or Sonnet 4, for example, let's say you want to use Sonnet 3.7 or even 3.5, what you can do is you can go to this website here

27:46So, this is just Anthropic's models website

27:48So if you go here and scroll down, there is a list of all the models that Claude Code currently has

27:55And let's just say that you want to use Claude Sonnet 3.5

27:57So, what you're going to do is just copy this name here

28:02Now, it's important if you're using Claude code to copy the name from this column here

28:05So, copy from this first column, copy this name, go back to here, exit out, and just write `/mod`, and then just paste in that name

28:15And now, if you hit enter, this is going to set Claude code to using that specific model

28:19And that's it

28:23The permissions command lets you control which tools Claude code can and cannot automatically run in your codebase

28:26If you have used Claude code before, you have probably run into this situation

28:33Claude tries to run a command, then pauses to ask for your approval, runs a bit more, then stops again

28:38waiting again for your approval for the next action, and so on and so on

28:42So, this is helpful for safety, but when it comes to development speed, it can really slow you down

28:48That's where the permissions command comes in

28:50Once you are comfortable with Claude's tools, you can specify which commands it's allowed to run without asking you, and which ones should still require manual approval

29:02So, Claude Code supports four types of permission rules

29:05So, 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

29:12So let's break each one down

29:15The first is the bash commands

29:17So 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 or terminal instructions like running scripts, searching and editing text files, installing packages, and so on

29:34And when it comes to permissions for bash commands, you can allow specific bash commands using exact matches or wildcards

29:38Okay

29:41So now let's look at this in Claude Code

29:44So if I go to Claude Code and write /permissions, you can see that there are three tabs

29:49I have the allow, I have the deny, and I have the workspace tab

29:53So let's just say, for example, that you do a lot of Node.js JS projects and you want Claude Code to always be able to run npm run build without you having to always approve it in any projects

30:06So if I go to this allowed tab and I hit enter on here

30:08So in Here, if I write `bash npm run build`, this is now going to let Claude Code run this command without having you to ever approve it again

30:21And another cool thing is that Claude Code also supports wildcards for these bash commands

30:26So let's take a look at this example right here

30:30So for this example, I have `npm run test *`

30:33So this is kind of saying that anytime Claude Code encounters a command that starts with `npm run test`, it will always approve it

30:40So let's say that you have `npm run test coverage`, that is going to be auto-approved because you have this here

30:47So that's the first type, bash

30:49Now let's look at the read and write

30:51So these permissions control which files Claude Code can read and edit, and they also follow the Git

30:56Ignore filters if you're familiar with Git

31:01Okay, let's go take a look at an example

31:04So I'm just going to open up VS Code and I have this hello.py file

31:06Now, currently, if I go to Claude Code and I just type out this statement of "add a print 'hi' statement to the hello.py file," what's going to happen is that Claude Code is going to need my approval first before it can edit this file

31:24So, just give it a few seconds and see right here, it's going to ask me for approval to add this file

31:30But let's say that I don't want this, I want Claude Code to auto-approve this

31:34How can I do this? So, to do that, let me just exit out of this

31:36Let me just go to permissions

31:38And in here, within my allowed tab, what I'm going to do is I'm going to add a new rule

31:42So, I'm going to hit enter

31:44And then here, I am going to add a rule of edit

31:47Now remember, this is how it looks like

31:49This is how it looks like for edit

31:51So I'm going to go to edit hello.py and then just hit save

31:56And I'm going to save it into my project settings

31:59Hit enter

32:03And then now I have this new rule that allows me to edit into this hello.py file

32:06So now I'm going to exit out of this

32:08And what you need to do is you actually have to exit first in order for cloud code to refresh

32:12So I'm going to exit this, re-enter cloud code

32:14And now I'm going to ask that exact same command

32:16So I'm going to ask this exact same command and see what happens

32:20Now I hit enter, and then it says it's going to add it, and then there it's done

32:24Now it says this file now contains that statement

32:26So let's go take a look

32:28If I open up this file, and there it is

32:30So that's the second type, read and edit

32:32Now let's look at web fetch

32:35So Claude Code can also fetch information from the web, but normally it'll ask you before doing so

32:42So, if you want Claude 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 going to add a new rule of web fetch, and then here, just enter the website that I want

32:57So I'm going to say google.com, hit enter, and just hit my project settings

33:02And then now, if I just refresh, let's exit this

33:06Go Claude

33:10And let's just say search Google to see what time it is in New York City

33:13Hit enter

33:16And then now it should be able to search Google without me having to approve

33:19And there it is

33:20It just says what time it is

33:21Okay

33:22Now let's look at MCP

33:24So for MCP, these permissions control which server tools you can allow

33:29So you can allow or restrict certain tools within an MCP server

33:34So, for example, here, this is saying that this allows you to use any tools within the puppeteer server

33:38But if you want to get more specific, you can say to allow or deny a specific tool within that server, such as the navigate

33:47Now, if you want to delete a rule, it's really simple

33:49All you've got to do is go into your permissions, find the rule that you want, hit on it, and just say if you want to delete or not, and that's it

33:56Now, here's something important

33:58Be very careful with permissions

34:00Don't just copy someone else's permission rules unless you understand exactly what each command does

34:07Allowing Claude Code to automatically run tools, especially ones that create or edit files, can cause major problems if misused

34:14The PR comments command lets you view the comments from a GitHub pull request inside Claude Code, and the review command allows Claude Code to review a GitHub pull request for you

34:27So, the status command shows your working directory

34:33It shows what account you're logged into

34:35So, if you have the Max or Pro plan, make sure you are actually logged into that and not the API version

34:41It also shows you what type of memories you currently have, as well as which model you're using

34:45So, This is a great command just to kind of get an overview of your entire codebase

34:49The terminal setup command allows you to use the option plus enter keyboard shortcut to enter new lines

34:56And for the Vim command, if you are a Vim user, this command will put Claude Code into Vim mode, enabling Vim style key bindings

35:07So if you're not familiar with Vim, don't worry about it

35:09Personally, I don't use Vim, so I skip this one

35:13And that's it

35:17This is a full overview of all the commands Claude Code has to offer and how they work and how to use them effectively

35:21I know this was a lot of information and some topics like MCP go much deeper than what we covered here, but don't worry, I'll be making more videos on those topics soon

35:31And I hope this was helpful and cleared up some confusions around some of the commands that Claude Code has

35:37If 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.