Every Claude Code Concept Explained for Normal People

You're probably staring at claw code thinking, "How is this supposed to make my life easier?" A black screen, a blinking cursor, and terms like context window, sub aents, MCP servers. None of

it feels like it's built for somebody without a coding background. So, you

jump between random tutorials and scattered docs, half understand one concept, and get stuck on the next and waste hours trying to connect all of those pieces that were never clearly explained. So without a solid mental

explained. So without a solid mental model of how this tool works, you'll keep second-guessing every command leading to slower builds, broken automations, and projects that you never end up shipping. Now, after hundreds of

hours inside Claw Code, building production apps, automating revenue generating businesses, and helping thousands of nontechnical founders use it confidently, I'm going to give you today the shortcut that I wish I had.

I'll break down 27 Claude Code concepts, each explained in less than 60 seconds, starting from the basics and stacking all the way up. So by the end you won't just recognize the terminology, you'll

know what to use, when to use it, and how to build without feeling lost every single time you open the terminal. So

let's get into concept one. Now we're

going to start by talking about what is claude code. So most people already know

claude code. So most people already know chat bots like Chat GBT, Claude, Gemini.

You type a message, you get a reply. But

those tools can only talk to you. They

can't actually do anything on your computer and they've only recently been given access to do anything even more than that like web search. Now Claude

Code is entirely different. It can

create files, build websites, set up databases, install packages on your machine, do your repetitive task, all from a simple conversation in plain English. So, you describe what you want

English. So, you describe what you want and it builds it. You don't need to know how to code. You just need to know what to install or how to write to get good answers back. So, chat bots give you

answers back. So, chat bots give you advice, clawed code takes actions, which brings us to the terminal. Now, claw

code doesn't run in a browser like chat.

It runs in the terminal. that black

screen with white text that looks so cryptic that you've probably seen developers use. Now, the terminal is

developers use. Now, the terminal is actually really simple. It's just

another way to interact with your computer. So, instead of clicking

computer. So, instead of clicking buttons, you type commands. But here's

the thing. When you're using Claude code, you don't need to know many terminal commands at all. So, you type in plain English and Claude handles everything else underneath it. Say I

want to install a package, I'd usually type in something like npx install package name. Getting my package manager

package name. Getting my package manager to install a given package name. Now

with claw code I just need to know a few commands. How to open it. So we type in

commands. How to open it. So we type in claude. How to close it? We hit control

claude. How to close it? We hit control C twice. And how to clear its memory.

C twice. And how to clear its memory.

We'll come to these but clear. And then

we also need to know how to talk to it.

Well, which brings us on to prompts. Now

a prompt is simply what you type to tell claw code what to do. Same as when you're typing something into chatbt.

That's it. You write prompts in plain English like build me a landing page.

Create me a dashboard. Fix this error.

There's no special syntax, no code. Just

describe what you want and the more specific you are, the better the result.

So instead of build me a website, say something like build me a one-page landing page for a consulting business with a green color scheme. I wanted to have a contact form and three cards explaining our service. So better

prompts, better results. And that is really the whole game when it comes to claw code. But we'll come to a concept

claw code. But we'll come to a concept later which will make prompting much easier. Now, permissions is an

easier. Now, permissions is an incredibly important concept because claw code can make actual changes to your computer. So, it can create files,

your computer. So, it can create files, run commands, edit code, delete files even. So, by default, it asks for your

even. So, by default, it asks for your permission before it does anything significant. But if you're clicking

significant. But if you're clicking approve every 10 seconds in a project that's going to take a day, it really kills your flow. And there is a better way. So, I recommend that you start with

way. So, I recommend that you start with a default where Claude is asking approval on most actions. So, you get to understand exactly what it's asking for.

But as you start to get comfortable, you can preapprove specific actions so Claude works faster without having to stop you constantly. Now you can go nuclear and give it permissions to do absolutely anything using

the-dangerously skip permissions flag. But even Boris Churnney, the creator of Claude Code, says he never does this and instead you should use a permissions file in the /

settings.json file. You can edit this

settings.json file. You can edit this file directly or type in /ermissions and add commands to an allow list. So these

get saved to your settings.json JSON

file, which means you can check them into your repo and share them with your team even. So, everyone has exactly the

team even. So, everyone has exactly the same permission setup. And I know it looks incredibly confusing, but what you're actually seeing here is these specific things are fine. Everything

else still needs my approval. So, it's

the sweet spot between safety and speed, but there's still the question of what should you actually allow? Well, here's

my thinking for most projects. These are

actions that I feel are safe to preapprove. So, we're going to read

preapprove. So, we're going to read files and folders automatically. We're

going to run the dev server. So just

commands to actually start Claude testing on a dev server. We're going to run tests so that Claude can check its own work constantly. And we're going to allow for git operations. So things like uploading to GitHub, committing certain

changes, and keeping our version control in place. And then the things that you

in place. And then the things that you probably want to keep gated, actually requiring your approval are things like installing new packages, deleting files or folders, and anything that's probably touching the internet, API calls,

sending data. You should keep your eyes

sending data. You should keep your eyes on those and ask Claude to keep asking your permission for those. And here's

the nice thing. You don't need to write that JSON file by hand. Just tell

Claude, "Add the common safe permissions to my settings, reading files, running tests, get operations, starting the dev server, show me what you're adding before you save it." And Claude will actually go and do the hard work for you, and you will see what that is at

the end. So, permissions keep you in

the end. So, permissions keep you in control, pre-approve the safe stuff, gatekeep the risky stuff, and Claude is going to work much faster without you having to approve every single action that comes through. Now, concept 5 is

all about tool use. So, what makes Claude code more powerful compared to the regular Claude or Chatbt is that it has access to any tools. So, it has built-in capabilities that let it interact with your computer. That's why

it can actually take actions. So, the

main ones are really simple. We've got

read, so Claude can actually look at your files and data. We've got write, where Claude can actually create new files. And then we've got bash. Claude

files. And then we've got bash. Claude

can run commands like installing packages, running tests, or moving files around your computer. And you don't need to tell Claude which tool to use. You

just describe what you want and Claude picks the right tools automatically. So

we saw that in the last permissions example with bash ls which basically allows Claude to run the ls command in your terminal which is basically just used to list files. So it's something we permit Claude to do on its own without

approval. So you just need to understand

approval. So you just need to understand the concept of tools. You describe the goal still. Claude is still going to

goal still. Claude is still going to pick the tools. That brings us nicely onto the context window. So the context window is Claude's short-term memory. is

everything that Claude can see and think about at any given moment during a conversation you're having with it. So

every message you send, every file Claude has read, every response it's generated, all of that is going to live inside our context window. And it has a limit. So when a conversation gets too

limit. So when a conversation gets too long or too much info piles up, Claude is going to start losing track of the earlier stuff you said. And this is a phenomenon called context rot. That's

when outputs get worse and Claude seems to forget exactly what you've told it.

It's similar to on Chat GBT when you get hallucinations. But the fix is super

hallucinations. But the fix is super simple. We're going to keep our

simple. We're going to keep our conversations focused and start fresh sessions when you have to switch tasks or use the slashclear command or slash compact command to help you manage it.

And we'll talk more about those later.

So you can track context limits by the green bar at the bottom of the terminal.

So context window is Claude's short-term memory. And to get better results, we're

memory. And to get better results, we're going to try and keep it clean as we go through a session. So conversation

history is all about Claude code automatically saving your previous conversation. So every single session

conversation. So every single session you have is stored and you can get back to any of them. All you need to do if you close your instance is type claude- resume and this will drop you straight

back into the most recent conversation, the same project you just were in. It's

going to have the same context of the previous conversation and pick up right where you left off. So this shows you a list of all your previous sessions. You

can scroll through, see what each one was about, and pick the one you want to jump back into. And this is essential in practice because you're rarely finishing a big project in one conversation instance. So you build something, close

instance. So you build something, close your laptop, come back the next day, and instead of starting over, you just resume. So that brings us to token

resume. So that brings us to token usage. So when you use claude code, it

usage. So when you use claude code, it costs money. And the way that cost is

costs money. And the way that cost is calculated is through token usage. So a

token is roughly 3/4 of a word. So it

means a,000 tokens is roughly 750 words you put in the input or you receive in the output. So every prompt you send,

the output. So every prompt you send, every response that it sends back to you, every file that Claude reads, it's all going to use tokens. So the price depends on which model you're using. So,

we've got Sonet, which is cheaper, and Opus, which is more powerful but costs more. And Claude Code is going to track

more. And Claude Code is going to track your usage, so you can see exactly what you're spending. So, tokens are how

you're spending. So, tokens are how you're charged. You can keep an eye on

you're charged. You can keep an eye on your usage using the /cost and SL stats, which bring up the amount of tokens that you've spent in that given session.

Okay, so now you've got the foundations.

You know what Claude code is. You know

how it works and how to talk to it. But

up until now, it's still a blank slate.

This is where we're going to make Claude Code personal to you. Which brings us to claude.md. So every time claude code

claude.md. So every time claude code starts working on your project, it needs to know how you want to get things done.

So without guidance, it's going to completely guess. And guessing is

completely guess. And guessing is obviously going to lead to crap results for you. So claude.mmd is just going to

for you. So claude.mmd is just going to be a markdown file in your file structure where you write your preferences, your rules, your project structure in it. And Claude's going to read it first every single line. And

every time we open a new instance of Claude, it will say things like we use TypeScript. Always write using our brand

TypeScript. Always write using our brand voice. Don't ever use m dashes. And

voice. Don't ever use m dashes. And

you're going to write it once and claude code is going to follow it in every single conversation. It's possibly the

single conversation. It's possibly the most important file you're going to create in every single project. So think

of claude.md as your instruction manual for Claude and you're going to iterate on it over time, but benefit from making that forever. So memory, everything

that forever. So memory, everything we've covered so far lives within a single conversation. But what if you

single conversation. But what if you want Claude to remember things across multiple conversations? Now, this isn't

multiple conversations? Now, this isn't talking about bringing up previous conversations like the history we just showed. It's actually about recognizing

showed. It's actually about recognizing patterns that you do automatically and storing those so Claude can be even more personalized. So Claude.md was like our

personalized. So Claude.md was like our manual memory file. But Claude Code has also got an automemory file that lets Claw Code store your preferences and facts that persist between your different sessions. So if you do always

different sessions. So if you do always work in JavaScript or prefer a certain coding style or have specific project conventions, then that's going to be automatically saved to memory and Claude's going to know that every single time you start something new. So

although it's going to store those things on your behalf, you can actually ask it to add, remove, and review what Claude remembers about you and the way you work. So it's all about learning

you work. So it's all about learning your preferences over time, not just within a single chat. So you don't see the memory files in your project directory, but it is being built as you work. Now, next is compact context. So

work. Now, next is compact context. So

we talked earlier about context length.

When conversations get really long, the context window starts to fill up. So if

you don't manage that, Claude starts losing track of the important info. So

here's how we actually manage this. We

can either do it automatically. So when

it detects that the context is getting close to full, it automatically takes the key information, summarizes it, and clears out the noise. It passes the summary then to the next instance of the conversation, hopefully keeping the

important stuff. Now, this happens in

important stuff. Now, this happens in the background without you doing anything. when we get to around 85 to

anything. when we get to around 85 to 95% of the context window. But if you notice claw getting confused mid session, you can actually manually trigger this using the /compact command

and append some arguments like keep info about API calls that actually give it more specific instructions on what to keep and what is important. So memory

compacting keeps Claude sharper during your longer sessions and you can leave it to itself or you can help it by doing it at key stages. Now models when people say claw code they're actually referring

to a family of AI models underneath. So

each one has different strengths speeds and costs. So HiQ is the fastest and

and costs. So HiQ is the fastest and cheapest. It's great for simple quick

cheapest. It's great for simple quick tasks. Sonnet is the middleman. It's an

tasks. Sonnet is the middleman. It's an

allrounder good at most things and reliable. And Opus is the most

reliable. And Opus is the most intelligent. So it's going to handle

intelligent. So it's going to handle complex problems the things that require a lot of thinking but cost the most. So

you can switch between them actually mid conversation by using /model in the terminal and the key here is just match the model to the task. So use sonet for most things opus when it actually

matters and then hiq for very very simple tasks. Now denying access to

simple tasks. Now denying access to files is not talked about nearly enough.

Not every file in your project you want to pass to claw code. So some are massive and would just waste your contacts window. Some are going to

contacts window. Some are going to contain sensitive data like your API keys and passwords and some are just totally irrelevant. So you need a way to

totally irrelevant. So you need a way to tell Claude, do not touch these under any circumstance. So you do this in the

any circumstance. So you do this in the same settings.json file. So you can add

same settings.json file. So you can add a deny list that tells Claude which files and f folders are completely off limits. So here's what this looks like.

limits. So here's what this looks like.

Again, it's a little bit confusing when you read it. But what we're actually saying is you can't read my environment files. You can't read anything else in

files. You can't read anything else in my secrets folder. Don't read my credentials. And therefore Claude won't

credentials. And therefore Claude won't even discover these files. It won't

include them in search results and can't read them even if you ask them to directly. So deny rules in the

directly. So deny rules in the settings.json file are the proper way to

settings.json file are the proper way to do this inside claw code. Now talking

about making cloud code more custom.

We're talking about flags. So flags are options when you start and launch claw code. So they let you customize how

code. So they let you customize how claude behaves for that specific session before it even starts. So you can use things like d-model to choose model d-allowed tools to controls which tools

it has access to like reading or writing. You can use d-verbose to get a

writing. You can use d-verbose to get a more detailed output every single time Claude responds, so you know exactly what Claude's doing. Or you can do things like dangerously skip permissions, which is the nuclear option

that we mentioned earlier. So flags are just launch settings for Claude code.

They're entirely optional, but that's just a shortcut on how to load them in.

Okay, so now you've got the foundations and you know how to configure Claude Code to work your way. This next section is where things get really, really interesting. So these are the features

interesting. So these are the features that take claw code from useful to genuinely gamechanging in your workflows. So these are some of the

workflows. So these are some of the features that we deep dive into in our new Claude code course in our school community down in the description below.

So we take you from zero to expert in just a few days of work. We also provide you with a curated list of skills, hooks agents/comands for lots of different use cases, so

you're able to get the maximum output with minimal input. So check out the first link in the description if that sounds interesting. Otherwise, let's

sounds interesting. Otherwise, let's move on to concept 15. Now extended

thinking. Some tasks are super simple.

Rename this file for example. But some

tasks need Claude to genuinely reason through the problem before it acts. Now

we can use a more powerful model like Opus 4.6 to get better results. But

actually this is all about Claude's inbuilt extended thinking capability. So

when you need to plan a multi-step build, quick responses aren't going to be good enough. And extended thinking gives Claude a dedicated reasoning budget in tokens that he can use to think through the problem step by step.

Now, you don't need to do anything to activate this. You used to have to write

activate this. You used to have to write words like think, think hard, or ultra think in your responses. But now, by default, Claude code has the ability to actually use that thinking budget with a

cap of max budget for thinking tokens.

So, all you need to know is extended thinking is clawed reasoning before it actually takes any actions and it's on by default and has a max budget allocated with it. Now, throughout this video, we've been using what we call

slash commands. So, typing in slash and

slash commands. So, typing in slash and then a command following that. So, you

type a forward slash and a command name, and it triggers a specific action, a repetitive task that you want to take.

So, this could be slashinit, which sets up a new project and actually helps you create that claw. D file. It could be our /compact, which was shrinking our conversation to save the contact space,

or something like /clear, which wipes the conversation for a fresh start. And

if you forget any of them, you can just type in /help and it will actually show you a list of all the slash commands that you've got available to do those repeatable tasks. And it's important to

repeatable tasks. And it's important to know that you can turn any of your tasks that you do on a day-to-day basis into a slash command by just putting them in the slash commands folder in docord. So

just think of slash commands as shortcuts and /help shows you all of the shortcuts that you can use. Now there's

a build on slash commands which is skills. So claude code is a generalist.

skills. So claude code is a generalist.

It can do a lot of things to an okay degree, but for specific task types, like creating your social media strategies, it can do even better if you give it those specialized instructions to follow. And skills are just

to follow. And skills are just pre-written instructions that teach Claude how to do specific tasks really well. Whether that's building

well. Whether that's building presentations, writing good copy, designing frontends. When you ask Claude

designing frontends. When you ask Claude to do something that matches a certain skills description, it will read that skill file and it's not just one context file. It can have supporting files too

file. It can have supporting files too to understand best practices and optimal approaches. And then it will build using

approaches. And then it will build using all of that knowledge loaded in. So

skills are going to use more context because we're actually loading those files in if they're necessary, but they can improve the quality of your outputs.

So say you want Claude code to be a copywriter. You can find a copywriting

copywriter. You can find a copywriting skill and install it or you can create your own if you're an expert copywriter.

So skills are expert playbooks and Claude reads them before building based on the descriptions. Which brings us onto hooks. So sometimes you want

onto hooks. So sometimes you want specific rules to run automatically at certain moments after an event has taken place. But we don't need AI to do that

place. But we don't need AI to do that every single time and to spend AI tokens. So hooks are custom scripts that

tokens. So hooks are custom scripts that trigger at those specific points.

Whenever Claude saves a file, we're going to auto format that file using our rules that we auto format with every single time. Or we're going to log every

single time. Or we're going to log every single command that Claude runs. So

setting those up requires a little bit more technical knowhow, although we can just ask Claude code to do that. But you

can think of them as custom rules that trigger automatically every single time.

They're guard rails that are going to run in the background and not use any AI tokens. So MCP servers by default clawed

tokens. So MCP servers by default clawed code works with files on your local computer. But I know that your business

computer. But I know that your business doesn't just live on your machine. It

lives across Air Table, Notion, Asana, and dozens of other tools. So MCP just stands for model context protocol. And

in simple terms, MCP servers connect Claude code to those external tools. And

once you're connected, Claude can pull data from those tools, push updates to them, and interact with your full text stack from that single conversation window. So this is what makes it super

window. So this is what makes it super powerful because it can actually take actions not only on your desktop, but in the apps that you use day-to-day. So

let's move on to sub agents. So far,

everything we've covered runs in a single conversation, one terminal, one context window, and that works for 80% of your daily tasks. But the longer a session runs, the more that context is going to pile up and Claude is going to

start forgetting things. We talked about using compact earlier. But actually,

there's another way to stop that, and that's actually just delegating to sub agents. So sub agents are specialists

agents. So sub agents are specialists that run in their own separate context window with their own system prompt, their own tool access, but still follow the main claude. MD file. So your main instance on screen is going to hand off

a task and the sub agent is going to do the work independently and then send back to the main agent the result. And

there's two reasons to use them. First,

you're going to improve the output quality. So, a focus specialist with a

quality. So, a focus specialist with a clean context window is going to beat that generalist with too much information. And secondly, it's speed.

information. And secondly, it's speed.

You can run multiple sub aents in parallel on unrelated tasks. And it's

similar to skills, hooks, and commands.

We can either create our own agents in the agent folder, or we can actually leverage others and download other people's agents as specialists, too. So,

a general rule of thumb is to use a skill when you want Claude to be better at something in your current conversation. But you're going to use a

conversation. But you're going to use a sub agent when the task is going to be entirely self-contained. So go away,

entirely self-contained. So go away, analyze this report and come back with your findings. Something that it can do

your findings. Something that it can do unsupervised. So think of sub agents as

unsupervised. So think of sub agents as focus specialists with their own context. And also by the way, Claude

context. And also by the way, Claude Code will spin out sub agents whenever it deems that architecture necessary. So

you don't even need to tell it to spin off those sub aents. Now sub agents have a limitation which brings us to agent teams. So sub agents can only report back to the main agent. So if you have a researcher, a writer and a reviewer as

sub agents, the reviewer can't see the research directly and the researcher can't see the reviewer's feedback. So

everything at this point is flowing through the main agent and that becomes a bottleneck when you have say five or more sub agents reporting into that main agent and agent teams a newer feature of claw code is designed to solve this. So

instead of that hub and spoke model where everything goes through one central point, teammates can actually communicate directly with each other and they share a task list. So the main agent spins up teammates only when you

ask it to actually spin up an agent team and each runs in their own claw code instance. So they get a sample of the

instance. So they get a sample of the information but not the full context of the main conversation history. So if

you're doing something more complex like building a SAS app then you might have an API developer, a front-end developer and a tester all working in parallel as separate agents because they actually need the context of what each other are

working on and to feed it back to a shared task list. And here's the simple rule for when to use what. So a single agent for one feature. If you have one conversation or one file that needs changing, then let's just use a single

agent. Sub agents when you need

agent. Sub agents when you need specialists and your context is getting bloated. And then agent teams when you

bloated. And then agent teams when you have a really complex build which actually requires collaboration between the team. So multimodal support or image

the team. So multimodal support or image screenshot support. Sometimes describing

screenshot support. Sometimes describing a problem in text takes way longer than just showing it. So claw code actually allows you to just upload your screenshot. So, say for example, you've

screenshot. So, say for example, you've got a bug on your website. You can

actually just screenshot it, paste it in. Claude will see exactly what's

in. Claude will see exactly what's wrong. It knows how to read images. And

wrong. It knows how to read images. And

you can also use this in reverse. You

can actually paste in a design that you like the look of and ask Claude to build to match it. Now, it's not going to get it perfect, but it's going to get it to a 60 70% version in the first shot. But

just keep in mind that images do use context, but it's a quick shortcut on how to actually put in things like images like you would in chatbt, which is way faster than describing problems in text. Now, Claude doesn't get

in text. Now, Claude doesn't get everything right. So, especially when

everything right. So, especially when it's working autonomously, it makes a lot of changes quite quickly. And if it goes down a wrong path, then you need a way to actually undo. So, thankfully,

Claw Code automatically creates checkpoints, which are session level snapshots of your code at certain points. So before every file edit, it

points. So before every file edit, it will create a snapshot. And you don't even need to do anything to enable this.

It's just going to happen in the background. So when something goes

background. So when something goes wrong, you can just type /re and that will open a list of every prompt from your session. And you can go back and

your session. And you can go back and pick the point that you want to go back to. And it will show you which ones

to. And it will show you which ones actually had changes in the codebase.

And you can choose what you want to restore, just the code or just the conversation. So checkpoints happen

conversation. So checkpoints happen automatically before every edit. And you

use /re to go back to them. All right.

So you now understand claude code from top to bottom. There are a few more practical concepts that matter when you're using this in the real world. So

the first is git integration. So when

cloud code makes changes to your project, you need a way to track what changed, when it did, and why it did. So

that is what we use git or github for.

And it's just our version control system. It tracks every single change

system. It tracks every single change made to our project over time. So all we need to do is actually connect up our GitHub account to claw code. And this is actually going to be what powers the checkpoint system. and it's how we can

checkpoint system. and it's how we can review Claude's changes, roll back specific edits, and work with a team without overwriting each other's work.

So, you don't need to be a Git expert.

It's actually just going to run in the background and keep everything trackable and safe and allow us to do those rewinds. Now, these last ones are going

rewinds. Now, these last ones are going to be super helpful and often get missed. So, normally Claude code is very

missed. So, normally Claude code is very interactive. You're typing, Claude Code

interactive. You're typing, Claude Code is responding, you approve sections, and you go back and forth. But if you want claw code to work completely on its own with no human in the loop, use what used to be called headless mode. whereas it's

now officially called CLI mode or command line interface mode. So with any task, you can add the -p flag to your command and it runs a full agentic loop independently. So you don't need any

independently. So you don't need any conversation with it is for no approval prompts, no waiting on your input. It's

going to process the request and output the results back automatically. And this

is where the flags that we covered earlier are really critical because if you want to pre-approve certain tools or not allow it to do certain things, then you can set that up front with that command by just using the d-allowed

tools flag. So it can do things

tools flag. So it can do things automatically without your input. And if

you want to take this one step further, then I'd highly recommend looking up the Ralph loop. It's an official Claude Code

Ralph loop. It's an official Claude Code plugin named after Ralph Wigum from The Simpsons. What it's basically doing is

Simpsons. What it's basically doing is instead of claw co code running once and stopping like we're doing with the headless mode, the Ralph loop keeps feeding in the same prompt, but as the files are continually built, it feeds in

the prompt with the new set of files and works out what's left to do on the task.

So Claude is literally going to iterate on its own while this while loop runs until it actually nails the task. And

people have used that to actually ship entire projects overnight. So it's like headless mode on steroids. And I'll

leave a link down in the description if you want to check that out. But going

back, the P flag turns claw code from a conversational tool into something that you can actually just get to run by itself. Now, let's cover the

itself. Now, let's cover the allimportant cost here. So, there are two ways to pay for claw code. And

picking the wrong one is going to cost you more. Claude Max is a monthly

you more. Claude Max is a monthly subscription. So, you can either do $100

subscription. So, you can either do $100 or $200 per month. You can actually start on Pro, which is around $20 a month. It has generous usage limits, all

month. It has generous usage limits, all models included. It's simple and

models included. It's simple and predictable and tells you when you run out. Or you can use the API as pay as

out. Or you can use the API as pay as you go. So that's going to charge you on

you go. So that's going to charge you on per token. So for light usage, that

per token. So for light usage, that might actually be cheaper for you. But

actually, what you're probably looking to do is go for the pro or max options to get a much better deal because midbu you don't want to be worrying about the amount of tokens you've used or the amount you're spending. You just want a

fixed monthly cost. The final concept, which is very important, and that's work trees. So when you're working on a

trees. So when you're working on a bigger project, you often need to work on multiple things at once. A new

feature that's not related to the main development, a bug fix or an experiment even. So you don't want them to

even. So you don't want them to interfere with your production environment. So what if you could have

environment. So what if you could have multiple claudes working on different tasks at the same time and that's what work trees give you the ability to do.

They do that by creating separate working directories that each have their own files and own branches but they still share the same repository history.

So it means you can have a claude working on a feature in one work tree while fixing a bug in another workree without either session convoluting each other's context. And to activate this

other's context. And to activate this claude code has a built-in flag for you to use. So you can just use the d-work

to use. So you can just use the d-work tree or the -w flag to create an isolated work tree and start cla in that work tree. So the value you pass after

work tree. So the value you pass after w-workree becomes the directory name and the branch name. So here's what this looks like in practice. I open three terminal panes. In the first one, I type

terminal panes. In the first one, I type claude-workree feature orth. Second one, claude-workree

feature orth. Second one, claude-workree bugfix login to fix my login page and claude worktree refactor API in the third as well. So now I've got three

claudes working on completely different tasks in completely separate copies of my code. So they can't overwrite each

my code. So they can't overwrite each other's work. They can't interfere with

other's work. They can't interfere with each other. When it finishes, I can

each other. When it finishes, I can merge that branch back into my main project just like any normal working flow where you merge things together. So

when you exit that work tree session, this is the most powerful thing. Claude

is going to handle the cleanup based on whether you made changes or not. And it

gets even more powerful because you can actually have sub agents also work on separate work trees. So you can ask Claude to use work trees for your agents and then each sub aent will get it entirely separate work tree and it's

automatically cleaned up when the sub aent finishes. Work trees means multiple

aent finishes. Work trees means multiple claudes working on different tasks simultaneously. This allows for total

simultaneously. This allows for total isolation and parallel development. So

there you have it. Every core claude code concept explained in plain English.

So don't worry about memorizing all 27 right now. Bookmark this video and come

right now. Bookmark this video and come back to it when you hit a concept and you don't understand it. And if you want to get hands-on and start building real projects with claw code, we've got a full claw code track inside the AI

automation academy down in the description below. Let me know in the

description below. Let me know in the comments which concept was the one that finally clicked for you.