16:42bri · Tutorial
CLAUDE.md Complete Guide: The File That Makes Claude Code Actually Useful
A screen-recorded walkthrough of building a lean CLAUDE.md and the full four-layer Claude Code extensibility system from an empty repo.
July 5thThe argument in one line.
Claude Code's real learning curve isn't the terminal, it's context: the habits that protect your token budget (new sessions per task, tight prompts, verification, plan mode) matter more than any single command.
Read if. Skip if.
READ IF YOU ARE…
- You're on Claude Code's $20 plan and keep hitting the usage limit after a prompt or two.
- You want a fast, tier-ranked rundown of which Claude Code features (skills, MCPs, subagents, worktrees) are actually worth your limited tokens.
- You're comparing Claude Code against Codex, Cursor, or OpenCode and want an honest read from someone who's used all of them.
SKIP IF…
- You're already deep into Claude Code's advanced workflows and don't need a beginner-to-intermediate feature tour.
- You're not using an AI coding agent at all, none of this applies without hands-on context.
The full version, fast.
A developer who's logged 1,000+ hours in Claude Code tier-ranks its features after hitting the $20 plan's usage limits too many times. Skills, plan mode, and verification (writing tests before implementation, using type checkers and browser screenshots) rank highest because they force Claude to check its own work instead of just claiming it's done. MCPs connect Claude to outside tools like GitHub and databases but shouldn't be spammed. The real lever on usage limits is context management: start a new session per task, don't let Claude wander into research tangents, and be specific in prompts, since tokens (not prompt count) are what get billed and what makes Claude "dumber" past roughly 100-200K of them. Automations, subagents, and worktrees round out the advanced toolkit, with Codex, Cursor, and OpenCode floated as viable alternatives.
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 – 00:51
01 · The usage-limit rant
Cold open venting about how fast Claude Code's usage limits get eaten on the $20 plan, and why the video exists: sharing the workflow, MCPs, and skills that make the limits survivable.
00:51 – 03:05
02 · What Claude Code actually is
Defines Claude Code as Claude specialized for coding that lives in the terminal but also runs in an IDE plugin and on the web, notes its rapid adoption (including by companies copying the format), and previews that its concepts transfer to other agents.
03:05 – 05:06
03 · /init and the CLAUDE.md file
Covers the /init command that scans a codebase into a CLAUDE.md memory file, the distinction from other agents' AGENTS.md convention (and how to import one into the other), the experimental interview-style /init, and what actually belongs in a CLAUDE.md.
05:06 – 06:41
04 · Skills
Explains skills as markdown files documenting a repeatable workflow, points to skills.sh and GitHub repos as sources, and flags favorite third-party skills for requirement-gathering and codebase-architecture review.
06:41 – 08:30
05 · Plan mode and the improve skill
Plan mode (Shift+Tab) makes Claude write and show a full plan before changing anything, recommended for big tasks only. Leads into an emerging pattern: a skill that only writes plans, pairing an expensive model for planning with a cheaper model for execution.
08:30 – 10:08
06 · Verification
Verification, framed as basic software engineering rather than an AI-specific trick, covers writing tests before implementation, running type checkers and linters, and using screenshot or browser testing so Claude can actually see what it built.
10:08 – 11:23
07 · MCPs
MCPs give Claude access to tools outside the codebase, GitHub, a database, Slack, a browser, and should follow the same restraint as skills: install only what a task actually needs.
11:23 – 12:49
08 · Quick-fire commands
A rapid tour of smaller commands: /voice for talking instead of typing, /btw for a side question that doesn't touch the task, Teleport and Remote Control for moving sessions across devices, shell mode via a leading exclamation point, and /radio for lo-fi background music.
12:49 – 16:59
09 · Context management
The core argument: Claude Code bills by tokens, not prompts, and performance dips well before the stated 300K or 1M context limits. Lays out three habits, a new session per task, no research tangents, and stupidly specific prompts, plus what /context and self-triggered /compact actually signal.
16:59 – 18:08
10 · Sponsor: Brilliant
Dedicated mid-roll read for sponsor Brilliant's AI tutor, Koji, framed as a way to learn to code well enough that these AI workflows keep working instead of quietly replacing the user.
18:08 – 19:29
11 · Automations: /loop and /goal
/loop repeats a task on a schedule, like a cron job, powering standing automations such as auto-picking up open GitHub issues, a daily security sweep, and feature brainstorming. /goal gives Claude an end-state to keep iterating toward until it's met.
19:29 – 20:32
12 · Subagents
A subagent is a separate mini-Claude spun up by the main session for one job, with its own context window, reporting back a summary. Powerful, but each one runs as a full parallel conversation that drains usage fast.
20:32 – 21:47
13 · Worktrees
Worktrees check out multiple branches of the same repo into separate folders, enabling parallel, isolated development, with every new chat treated as its own worktree.
21:47 – 22:30
14 · Alternatives to Claude Code
Closes with alternatives for viewers who don't want Claude Code: Codex, OpenCode, a minimalist option called Amp, Cursor, VS Code with GitHub Copilot, and t3 code as a control plane across multiple coding-agent subscriptions.
Lines worth screenshotting.
- Claude Code bills by tokens, not by prompts, so one vague request that makes Claude read half the codebase can burn more usage than ten precise ones.
- Once a Claude Code session crosses roughly 100,000 to 200,000 tokens, output quality starts dropping, even though the context window goes up to a million.
- Telling Claude to write tests first and implement second is real verification. Telling it to implement first and test after just means it writes tests that pass its own code.
- The most effective skill isn't one that writes code, it's one that only writes a plan and hands execution to a cheaper model, since the expensive model's job is understanding the codebase, not typing.
- Claude Code's own compact command firing automatically mid-task is a signal to start a new session, not to keep going, since a self-triggered compact visibly drops output quality.
- Claude Code reads CLAUDE.md, not AGENTS.md, so teams running multiple coding agents need CLAUDE.md to import the AGENTS.md file rather than duplicate it.
- A skill is just a markdown file describing a repeatable workflow, which means the best ones are effectively senior engineers publishing their best practices as a single readable document.
- Starting a brand-new session for every new task beats reusing one long conversation, because every task after the first degrades in quality as accumulated context piles up.
- MCPs are only necessary when Claude has to reach outside the codebase, GitHub, a database, a browser. Best practices and how-tos belong in a skill instead.
- Subagents run as fully separate parallel conversations, which is why a small multi-agent setup can burn through an entire $20-plan usage limit before the task even finishes.
The features worth your limited Claude Code tokens
CLAUDE CODE WORKFLOW
A 1,000+ hour Claude Code user tier-ranks the tool's real features, arguing the usage limits everyone complains about are mostly a context-management problem, not a pricing problem.
02What Claude Code actually is
- Claude Code works both in the terminal and inside an IDE via a plugin, so a preference for visual tools over a terminal isn't a reason to skip it.
- Wide adoption, including by companies rushing to copy the format, signals Claude Code concepts are becoming standard across coding agents, not proof it's the only tool worth learning.
03/init and the CLAUDE.md file
- CLAUDE.md becomes a project's permanent memory across sessions. Keep it to a project description, current status, and coding style rather than treating it as mandatory scaffolding.
- Claude Code reads CLAUDE.md specifically, not the AGENTS.md file other agents use, so cross-tool teams should have CLAUDE.md import AGENTS.md instead of duplicating content.
- An experimental /init flag turns the command into an interview instead of a one-shot codebase scan, and also recommends skills and hooks to install.
- A CLAUDE.md file is not make-or-break. Skills alone can get comparable or better results.
04Skills
- A skill is just a markdown file describing a repeatable workflow, best practice, or research process the agent can invoke automatically or on command.
- Community skill libraries like skills.sh let you install another engineer's documented best practices directly into your own agent.
- Don't install skills in bulk. Stick to one coherent set that matches your actual coding style, since many skills encode a subjective opinion about good code.
05Plan mode and the improve skill
- Plan mode (Shift+Tab) makes Claude research and write a full plan before touching any files, and it's far easier to catch a mistake in a plan than buried across thousands of lines of changed code.
- Use plan mode for big tasks only. For small edits like typos or variable renames, it just burns tokens without improving the result.
- The strongest emerging workflow: have the most capable, expensive model write a self-contained implementation plan, then hand execution to a cheaper, faster model.
06Verification
- Claude has no way to know if its own code is correct without being told to check. Verification is what turns 'looks done' into 'is actually done'.
- Write tests before implementation, not after, or the tests just get shaped to match whatever code Claude already wrote.
- Type checkers and linters are a fast, low-effort verification pass. Run them before considering a task complete.
- For front-end work, screenshot testing and browser-driving let Claude actually see what it built, since it can't otherwise perceive its own UI output.
07MCPs
- MCPs are for connecting Claude to things outside the codebase, GitHub, a database, Slack, a browser, not for storing best practices, which belong in a skill instead.
- Apply the same restraint to MCPs as skills: only install what a given task actually needs, not a large standing collection.
08Quick-fire commands
- Voice mode often produces more descriptive prompts than typing, since talking it out surfaces intent that gets lost when typing quickly.
- A side-question command that only reads conversation history, without touching files or the task, is useful for asking why Claude made a decision mid-session without derailing it.
- Shell mode, entered by prefixing a message with an exclamation point, drops into a normal terminal that Claude can still see the output of, a fast escape hatch mid-session.
09Context management
- Claude Code bills by tokens consumed, not prompts sent. Every file read and every response written draws down the same budget.
- Performance measurably drops somewhere around 100,000 to 200,000 tokens of context, well before hitting the stated 300K or 1M limits.
- Start a fresh session for every new task. Reusing one long conversation for multiple tasks degrades quality on each successive task.
- Being stupidly specific in prompts prevents Claude from reading the whole codebase to guess what you meant, one of the biggest silent token drains.
11Automations: /loop and /goal
- A recurring-task command runs a task on a set interval like a cron job, enabling standing automations such as auto-picking up open GitHub issues or running a daily security sweep.
- A goal-driven command gives Claude an end-state to work toward, such as all tests passing with no type errors, and it keeps iterating until that goal is met or it needs help.
12Subagents
- A subagent is a separate mini-Claude instance the main session spins up for one job, research, review, or debugging, with its own context window, reporting back a summary when done.
- Each subagent runs as a full parallel conversation, so a small multi-agent setup can exhaust an entire $20-plan usage limit before the underlying task even finishes.
13Worktrees
- A worktree checks out a separate working copy of the same repository into its own folder, letting multiple branches be developed in parallel without one agent's changes interfering with another's.
- Treating every new chat as its own worktree removes the need to wait on one branch before starting the next.
14Alternatives to Claude Code
- Codex, OpenCode, Cursor, and VS Code with GitHub Copilot are all viable alternatives depending on which subscriptions and workflows already fit.
- Tools that act as a control plane across multiple coding-agent subscriptions let you use Claude Code, Codex, OpenCode, and Cursor from one place instead of switching between separate apps.
- The underlying lesson applies across tools: skills, verification, context management, and subagents generalize, so learning them isn't wasted if you switch agents.
Terms worth knowing.
- CLAUDE.md
- A markdown file Claude Code reads at the start of every session in a project, used as its permanent memory for project context, coding style, and rules.
- Skill
- A markdown file (skill.md) describing a repeatable workflow or best practice that Claude can pull in automatically or on command, instead of re-explaining the same instructions every session.
- Plan mode
- A Claude Code mode, triggered with Shift+Tab, where Claude researches and writes a full plan before touching any files, and the user approves or rejects it before execution begins.
- MCP
- A standard that gives Claude Code access to outside tools and services, like GitHub, a database, or a browser, beyond just reading and writing files in the project.
- Context window
- The total amount of text, measured in tokens, Claude can hold in short-term memory during a session. Performance degrades well before the window is actually full.
- Subagent
- A separate mini-Claude instance the main agent spins up for one specific job, research, review, or debugging, with its own context window, reporting a summary back when done.
- Worktree
- A Git feature that checks out a separate working copy of the same repository into its own folder, letting multiple branches be worked on in parallel without interfering with each other.
- /compact
- A Claude Code command that summarizes the entire conversation history into a shorter version to free up context space. When Claude triggers it automatically mid-task, output quality typically drops.
- /loop
- A Claude Code command that repeats a given task on a set time interval, functioning like a cron job for recurring AI-driven work such as picking up open GitHub issues.
- Token
- The unit Claude Code's usage limits and pricing are measured in. Every message sent, file read, and response written consumes tokens, regardless of how many prompts were typed.
Things they pointed at.
Lines you could clip.
00:08
“I have spent an unhealthy amount of time using Cloud Code, and I gotta get this out of my chest already. Their usage limits suck.”
14:05
“Claude has a dumb zone. The more context you use, the dumber Claude gets.”
08:10
“This isn't just an AI thing. This is just good software engineering fundamentals. AI just makes this more important.”
07:00
“Use your most capable model for the part where intelligence compounds, understanding the codebase, judging what's worth doing, writing the spec, and hand execution to cheaper models.”
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.
metaphoranalogy
I have spent an unhealthy amount of time using Cloud Code, and I gotta get this out of my chest already. Their usage limits suck. Oh my goodness.
I say hi and boom. There goes my limit, and I gotta wait three hours. And with this new Claude Fable model fuck.
I recorded a lot of this footage like a month ago. So, I know. It's not new.
Leave me alone. Just laughing my jokes. Okay?
I've been programming with a $20 plan, and I have had situations where I prompt once or twice and I hit the limit. Like, bro, no wonder people are getting better results. They don't get enough time to use it properly.
I'm glad they're making it better, but it's painful. So I wanna share everything that I've learned so you can use it effectively. So things like my workflow, my favorite MCPs, my favorite skills, and I'll also share some ways you can save on some tokens so you can actually use it more.
Trust me. I've learned some strategies use as little tokens as possible so I can get my money's worth because I am not spending a $100 a month for this. That's expensive, and I'd rather spend that on a McDonald's.
Okay. So what's Claude code? It's Claude, but for coding, you're welcome.
No. But really, it's Claude, but it's specialized for coding, and it lives in your terminal. Now do I like the terminal?
Meh. I prefer the IDE approach, specifically the IDE and agent combo approach. You get the agent interface and an actual IDE.
Plus, there's buttons I can actually click. I'll take that over a terminal any day. What can I say?
I like visuals. I'm a toddler. The good news is you can use Cloud Code in your IDE and on the web.
Pretty cool. Now why have I been using it? Well, everyone and their moms are using it, even big tech companies.
Some a little too much, Uber. It also made, a billion dollars in six months, which is pretty crazy, and that made every other AI company copy and paste Cloud Code, and now we have this mess. And every company wants you to learn these types of tools so you can become a 10x engineer so they can give you more work, and that also didn't work because it was too expensive.
They also gave me some free stickers, which is pretty cool. Do I recommend you learn it? Yeah.
Pretty helpful until you hit those usage. Yeah. It's pretty convenient.
Jobs want you to learn it. And if it gets you a better chance at a job, hey. You gotta do what you gotta do.
The good news is a lot of these Cloud Code concepts apply to other coding agents, which means I can give you some alternatives to Cloud Code since this video is not sponsored. Okay. So let's go over the features of Cloud Code.
I've done my fair share of research. I've looked at some Twitter articles. I've watched YouTube videos.
I've seen Cloud's tutorials. I've watched videos and articles from the guy who freaking built the thing. As I was doing research for this video, I realized that Cloud Code has, like, 80 plus different commands and features that I have never seen in my life.
Did you know there's an UltraPlan mode? I didn't. Nobody else uses this.
I don't think I've seen the creator use this. Hey. Editor Sloth here.
I recorded that a month ago too, and, uh, UltraPlan doesn't even exist anymore. That's how useless it was. Yeah.
So originally, I was gonna go through every single one, but no. There's way too many. Most of them are just configuration or just useless.
So now we're only gonna cover the essential ones. And even then, I'm gonna tier rank them from how useful they are. Because in my experience, some of these features that people call essential, you're never gonna touch.
Now if you are serious and you do wanna learn more about programming and AI, you should check out my free newsletter, Slothbytes. Ho, you don't know what Slothbytes is? Slothbytes is just a newsletter I'm working on.
It's currently one of the biggest programming newsletters in the world. I made that up. I don't know if that's true.
And it's completely free. Where every week, I send you programming advice and news so you can stay up to date and not get behind. Did I mention it's free?
All I need from you is your sweet delectable email. Let's start with the slash init and claud file.
This is the command you're supposed to run when you first open up claud code in a project. So far in my experience, it's alright. Essentially, claud looks at your entire code base, and it puts it all inside this claud dot m d file.
This file becomes claud's permanent memory for the project. Now I have beef with Claude for this feature because other AI agents do the same thing, except they put it into an agents dot m d file. Claude is the only one that doesn't do this, which is very, very annoying.
The one nice thing about Claude files is you can actually import additional files. So if you are using an agents dot m d file, you can just import it inside the Cloud m d file, which saves you from having a SIM link. But it would be nice if, you know, Cloud just supported it, but it is what it is.
There's also a new experimental version of this command. You just have to turn on this environment flag, and this one actually has some potential. Instead of analyzing the code base and writing the file, it now interviews you, which is really good, and it'll now also recommend some skills and hooks, which is really nice.
We'll get into those in a bit. Based on my experience, I'm honestly gonna give this feature, like, a c or even a d. I don't use it very much.
Woah. Me from a month ago was really stupid. Yeah.
After a month, my opinion has changed, and it still stays the same. I think it's pretty mid, but the Claude file, I'm moving that up. After months of dealing with the sloppy code, you definitely start to get an idea of these AI models quirks and their habits, really disgusting habits.
And so for the most part, my claw dot m d file has information like a quick description of the project, current status of it, um, my coding styles, and I've also been testing some interesting things like this working philosophy. A funny rule I have in my file is a user facing capitalization. For some reason, when AI models create designs, they really love to use all caps.
No idea why, but it's ugly. Another thing I've been testing and liking a lot is setting the pull request language. But this is what I like to use so far.
This file can change quite a bit. Be flexible with it. But this file is honestly not a make or break thing.
You could easily survive not even having one. So don't freak out too much about it because you can honestly just use skills and you can get similar or even better results. Alright.
I haven't explained skill a tier. But if you're smart with it, easy s tier.
A skill is also just a markdown file, specifically a skill dot m d file. It's essentially a guide for something you do over and over that the AI can use when it makes sense or you can explicitly tell it to use it. It would be for things like your best practices, your workflow for something, or how you would research something, essentially any type of workflow that's repeatable.
Cloud Code has some default skills preinstalled like code security review, and some other stuff. I will give those skills like a b tier or a tier. I do recommend using them if Cloud implements a feature.
It's just a nice bonus. Personally, I freaking love skills, and I love that there's a whole community of them now because it's literally companies and genius engineers taking their knowledge and best practices and putting it all into one file. So not only is it useful for the agent, it's useful for me.
I've learned so much just reading other people's skills. So some of my favorite places to find skills has been the website skills.sh. This is my go to place for finding and installing skills, but there's also some other GitHub repos where you can find skills.
Uh, my favorite type of skills that I like to use are, uh, Matt Pocock skills. He must read a dictionary every day because his vocabulary is immaculate. Such a smart and brilliant guy.
I really like using his grill with doc skill, helps me refine my requirements, and I also like using the improved code based architecture skill. It's just a nice workflow. I also like that it comes with a nice visual.
I mean, hey. He won me over. Like I said, I'm a toddler.
I also like using cursors. I like this name. Thermonuclear code quality review skill.
Really helpful. It really simplifies the code that AI generates, which eliminates a lot of the slop. Strongly recommend you use this, and it actually combines really good with the improved code base architecture skill.
I've been using both of them at the same time, and I think they're pretty good. One of the recent skills I like to use is a improved skill.
I've been trying it out, and I'm loving it. I really love the idea here. It audits your code base, and it writes the plans for other agents.
Oh, yeah. Plan Easy s tier.
If you hit shift and tab on Cloud Code, Cloud goes into plan mode. Instead of reading and making changes, it reads your code more thoroughly, writes up a full plan, and it shows it to you before doing a single thing. And then you can either approve it or deny it.
This feature is a must for cloud models, I think. You get a higher quality result since now the model takes the time to explore and think about its actions before doing something. It's also way easier to catch a mistake in a plan than in, like, 3,000 lines of code and 12 different files it modifies.
I recommend using plan mode for a big task. Don't use it for small tasks like typos, renaming variables, or small design changes. That's just a waste, and you don't get much better results.
Anyways, back to the improve skill. It's such a good idea. It'll probably become the default strategy if it's not already.
Essentially, you would use the smart model to write the plan, and then you would use a cheaper, faster model to implement it. Now keep in mind, when I say faster and cheaper, that doesn't mean dumb. Some of these faster models are actually pretty intelligent now, which is why this workflow works.
You save way more money, and everybody loves money. Right? For example, if you were on Cloud Code, you would use the Fable model.
Oh, wait. That's gone. Again, that was recorded over a month ago.
It's not gone, but you do need usage credits, so it basically is gone. I guess you would use the Opus model for the plan and then Sonnet for the implementation. But if you're not using Cloud Code, cursor, OpenCode, Codex, then you can truly mix models.
But overall, my best practices for skills, do not spam skills and do not install a 100 of them. Some of these skills are pretty subjective since everyone has an opinion on good code, so I would also recommend sticking with one specific group of skills or skills that match your coding style. Since we're talking about coding styles and doing things the right way, let's talk about verification.
This isn't exactly a feature or a command. It's more so a workflow and best practice. And I'm giving this an s tier, and if anything, a double s or even a triple s because this isn't just an AI thing.
This is just good software engineering fundamentals. AI just makes this more important. So what exactly is verification?
Essentially, you're giving Cloud a way to check its own work before it considers something done. It actually has no idea if it's correct. But with verification, it can write the code and see if it's actually correct, not just telling you it's done.
Now there's multiple ways to verify, and the most obvious one is tests. But make sure you do tests correctly. Tell Claude to write the test first and then implement.
This is important. If you tell it to implement first and then write the test, it's just gonna write tests that pass its own code. And that's not exactly testing.
That's cheating. Make sure you don't test every single line. Just test the most important things.
I've noticed that smarter models like to test every single thing when it's really not necessary and it kinda just bloats your code base. Some other ways to verify are type checkers and linters. If your language supports it, tell Claude to run it before considering the task done.
Two other ways you can do verification, and this is if you're doing front end and design work, is screenshot testing and testing with the browser because Claude is literally blind. It can't actually see what it's making. With these two verification methods, Claude can actually open your app, click around, get some screenshots, and actually see what's happening.
It's nice to see that AI models are getting good at using computers. You used to have to use MCPs, but now they're just built in. Oh, right.
MC b tier. Actually, I'm lying.
A tier. MCPs give Cloud access to other tools. So things like GitHub, your database, Slack, checking out your analytics, your deployments, and if you do front end work, a browser.
Some of the ways I like to use MCPs are for fetching design inspirations, database seeding, so adding fake data to test certain features, research and documentation, and, of course, browser testing. Now in my experience, I think you only need an MCP when Claude has to directly interact with something outside your code base.
There's really no reason to use an MCP for things like best practices, patterns, or how to implement something because the skill can handle that. The best practices for MCPs are basically the same as skills. Don't spam them.
Don't install a bunch of them. Only use what's necessary. Honestly, the big pattern with AI is only do what's necessary.
Let's quickly go over some features and commands I feel like not enough people talk about. I'll make it quick because they're simple but really convenient. Slash voice feature.
Cloud Code has a voice mode. All you have to do is type slash voice and just talk. And with this, whatever you say turns into the prompt.
I feel like in voice mode, it's easier to be more descriptive than typing. It lets you think out loud and understand what you want more, and I feel like it's better for maintaining your technical knowledge. It's also way faster than typing if you're slow at that.
Slash b t w. C tier probably won't use this much, but it's nice to have. It lets you ask a question mid task, and it doesn't interrupt Claude or touch the conversation history.
So you can ask about stuff Claude has already read or implemented. When you run this command, Claude can't read files or use any commands. It just uses the conversation history, but it's really nice to have if you have a question about something and wanna know why it's making these decisions.
I mentioned you can use Clot in different ways. Slash Teleport and Remote Control lets you move sessions between these apps. So you can move between your phone, the web, or the terminal, which I appreciate a lot because sometimes I just get that random genius idea or inspiration in the middle of the drive through line in McDonald's, and I really gotta tell Claude about it.
So I can start that in the mobile app, and when I get home, I can transfer it to my terminal. It's great. If you touch grass a lot, I'll give it an a tier, but I don't go out very much.
So personally, it's kinda like a c tier or d tier, but it is convenient. Shell mode, also a c tier, but I do think it's one of the more underrated features here. If you type god.
That was terrible. If you start your message with exclamation point, you enter shell mode, and this basically goes back to a normal terminal. But the difference in this mode is Claude also sees the output.
It's just a really convenient shortcut. Slash radio. F tier for productivity, but s tier for vibes.
This command opens up claud f m, which is just lo fi music you can listen to while you code. And, yeah, that's it. That's the whole feature.
I can't play the music because I don't know if it's copyrighted, but it's pretty chill. Let's be Not everyone here is rich with unlimited tokens. I can't just spend a million dollars worth of tokens and neither can big companies.
A lot of you are probably on the $20 plan like me, or maybe you're mister big bucks over here with the $100 or $200 plan. Either way, context management matters for all of you. You see, Claude tracks usage based on tokens.
It's not based on how many prompts you send. Every message you send, every file Claude reads, every response it writes generates token. The goal here is to make these tokens effective and last long for both your usage limits and Claude's performance because Claude has a context window that also relies on these tokens.
It's basically Claude's short term memory. Now the important thing here is Claude has a dumb zone. The more context you use, the dumber Claude gets.
It starts forgetting things, contradicting itself, and making dumb mistakes. Claude has two different context limits. One is at, like, 300,000 tokens and another one's at a million.
I think Claude code defaults to a million tokens. Now you would think the difference in 300,000 and a million for context would reduce the , but all it really does is extend the dumb zone. In my experience, once you're above, like, a 100,000 or 200,000 tokens, that's when the performance starts to dip a bit, and those usage limits get cut.
You can see Claude's context right now with the slash context command, and I'll give this command a b tier. I think it's pretty important to use, especially if you wanna get more advanced with AI. And I suggest running this command before you run a big task, but just being able to see the context window doesn't really do much.
How should you use your context? In my experience, to get the most out of this context window is number one, for every new task, start a new session. Every task after the first one is just gonna be worse quality because every time I run, like, a medium or big task with Cloud Code, it uses up a lot of context.
It's like always minimum 50,000 tokens it uses. And if you tell it to research or use a skill or an MCP, it could easily go above a 100,000 tokens. So if you do multiple tasks and you're just gonna go worst output and you're gonna run out of your usage limit real fast.
Number two, do not let Claude go on research tangents. If you notice that Claude starts to explore files or search topics it doesn't need, tell Claude right away not to do that. Because every file and website Claude reads is tokens you're spending.
If you have specific files and sources it should use, tell it to use it, which leads to the next tip. Be specific in your prompts. Stupidly specific.
If you give Claude vague prompts, it's just gonna read everything to figure out what you want, and this tip is very important for technical decisions. Now even with these tips, you'll probably end up in a task that actually uses the context limit. And when you do reach that limit, Claude is gonna run the slash compact command.
I'll give this command a c tier when Claude uses it, but if you know how to use it, it's probably like a b tier. This command summarizes the whole conversation history down into a shorter version so that if it's in the context window. If Claude runs this command on its own, that's your sign to just start a new session because when Claude compacts itself mid task, it basically .
You'll notice right away there's a bit of a quality drop. Now if you're on a task where you're positive it doesn't need a separate conversation, it's better to run the command yourself and tell it exactly what to keep. Now if you wanna optimize your context even more, there are some additional community tools built specifically for this.
I'll probably just leave them in the description so you can check it out. Ah, yes. You see, AI enthusiasts and software engineers have collectively discovered a revolutionary innovative solution with AI, the four loop.
Yeah. I'm not kidding. It's it's a whole trend right now.
I can't wait till we move on to object oriented prompting and then functional prompting and maybe a little bit of system prompting. I can't wait for this. No.
But honestly, it's incredible. And I blame the people saying, programmers are gonna get replaced or the ones saying, why would I ever need to learn to code again? This is why right here.
People are just reinventing the same thing over and over, just in a different font. And if you couldn't read code, you would never even notice. So please, learn to code.
We need more people with actual brains. Knowing how to code is the exact reason why all these tips work and why I get decent results from AI. I don't want you to be the type of programmer where you hit your usage limit and suddenly you can't even work on your own project because you never learned how any of it works.
And if that's you, you've already been replaced. I'm sorry. So if you are going to lean on AI, you should use it to do the work and make you smarter.
I mean, it's a win win. Brain bigger and AI does better work because brain big. You could have Claude teach you as you go.
I would recommend that. Make it explain every change instead of blindly smashing accept. But if you do want something more interactive and specialized where a tutor will walk your small brain through it step by step, you can check out today's sponsor, Brilliant.
And this isn't the Brilliant you remember. This is the new Brilliant, a super intelligent personal tutor for math and coding. Brilliant already had a world class curriculum.
It covers everything in math and coding from grade five to college and beyond. It's designed by experts from MIT, Harvard, and Stanford. It was interactive so that learning could feel fun.
But no matter how good a curriculum is, private tutoring will always be the single most effective way to learn. Obviously, not everyone can do this. It's expensive and annoying to schedule.
So that's what the new Brilliant is really about. Taking that personal tutor experience and making it something everyone can actually use. And that's where their new tutor Koji comes in.
It sits right there on your screen while you work. It sees what you're stuck on. It sketches, points, and hits you with the right guiding questions instead of just handing over the answer.
Basically, everything a great tutor does. It makes each lesson feel more like a puzzle than a lecture, and now you have someone to train you to think like a software engineer by helping you focus on logical reasoning and debugging. You can try Brilliant's new tutor for free and get 20% off an annual subscription by scanning the QR code or clicking the link in the description.
Go learn and make your brain bigger. Alright. So what's the deal with this life changing command?
I mean, slash loop, it's pretty straightforward. You give it a time interval, how often it should run this task, and it'll keep doing it. It's essentially like an AI cron job.
I mean, I'm not gonna lie. It is really convenient. I've been enjoying loops a lot because you can create automations because I'm not working on my personal projects every single day.
But with loops, I've been setting up these routines or automations, and it allows me to keep making progress even when I'm not actually there. Some of my favorite automations that I've been running recently have been, uh, implementing a GitHub issue where every day it'll pick from the open issues in my project and it'll work on it.
And so I come back and there's a PR waiting for me. Another automation I like using is security and bug sweep. It'll scan the code base for any known vulnerabilities or if it finds any bugs, and it'll flag what it finds and puts that into a GitHub issue.
And my third automation that I've been testing recently, feature brainstorming, where it's gonna look at the code base, the PRs, the issues, and it's gonna brainstorm features that would actually help the project. You can also run automations when certain things happen, but it lets you make some really sick automations. I think a lot of companies and open source projects are testing this, and they are getting some decent results.
It's honestly worth trying. Ask here. It's great.
This command is pretty straightforward. You basically give Cloud a goal, and it'll keep working on it until it completes it or it needs your help. So you can do something like make sure every test passed and there's no type errors and have that as a goal, and Claude will just keep doing it until it meets it.
I'll give this command, like, a b tier if you're on one of the lower plans. But if you are on one of the higher plans or you have unlimited tokens, it's definitely more so on the a tier. We have an agent, which is the main Claude chat.
This is the one you always talk to. You can think of this as the daddy agent, the Chad, the group leader, whatever works for you. And a sub agent is just a mini Claude your daddy agent starts for one specific job.
So this sub agent could be a researcher, a reviewer, a debugger. You can make as many sub agents as you want, and each sub agent gets its own context window. It does its thing, and when it finishes, it gives the a summary of what it did.
There's multiple ways to make one, but honestly, the easiest is just telling Claude to create the sub agent and a description of what it'll do. But realistically speaking though, most people can't run sub agents all the time because sub agents drain your usage limits so fast. Each sub agent is basically its own full conversation running in parallel.
And on the $20 plan, even a small multi agent setup can eat your entire limit before the task even finishes. But I will say, honestly, sub agents are still, like, in a tier. And if you do have unlimited tokens or you're on a higher plan, it's easily an s tier.
It makes the quality of the implementation so much better. A tier. WorkTrees is a feature that allows you to check out into multiple branches of the same repository.
Every time you create a work tree, it essentially copies the project into its own separate folder, and it's the perfect thing for parallel development with AI. The workflow I essentially use is that every chat is a work tree. So instead of working on one branch at a time and waiting around, you can work on multiple branches at once, And they're completely isolated, so you wouldn't have to worry about agents interfering with each other.
And Cloud Code does have native work tree support. So what if you don't wanna use Cloud Code? Well, that's great because it's not the only option.
One good alternative is, of course, Codex. It's OpenAI's version, and I personally love it. I think that's the one I've been using the most.
Their usage limits are actually generous. Our lord and savior, Tbow, keeps resetting them, so I get to use a lot, and I've been making tons of progress on my projects Thanks to him. There's OpenCode, which is essentially the open source version of CloudCode.
And if you wanna use any model, I do recommend you check it out. Another alternative that I've seen is, uh, one called Py. It's basically like a minimalist setup.
So if you're the type of person that wants to create their own workflow from scratch, this is the tool for you. And if you're interested in, an IDE and agent combo, there's cursor. It's what I like to use if I need to use an IDE.
This one also lets you pick any type of model. I like their own models. I like Grok and Composer.
They're so fast, and they're really cheap. And, of course, there's Versus Code and GitHub Copilot, the OG. Most of you know what Versus Code is.
And a recent one that's been getting really good is actually t three code. I'll just read it from their website. It summarizes it pretty good.
It's an open source control plane for coding agents. So if you have a cloud subscription, you'll probably enjoy the UI of t three code way more. But if you have multiple subscriptions, so if you have cloud code, codex, the open code, cursor subscription, if you have all of those, then maybe you should check out t three code since you can basically use all your subscriptions in just one application instead of going all over the place.
So go pick whatever AI tool you wanna use. If you wanna use cloud code, so be it. Enjoy those usage limits.
And when you do hit those usage limits, go watch more of my videos. I'll see you on the next video.
The Hook
The bait, then the rug-pull.
The video opens on a specific complaint: after burning enough hours in Claude Code to lose count, the usage limits still sting after one or two prompts. What follows is a tier-ranked tour of every feature worth keeping, and a case that the real fix isn't a bigger plan, it's better habits.
Named ideas worth stealing.
07:15concept
Plan-then-execute with tiered models
Use the smartest, most expensive model only for understanding the codebase and writing a self-contained plan, then hand the actual implementation to a cheaper, faster model.
Steal forany AI coding workflow where cost matters more than raw model IQ
14:22list
Context management rules
- Start a new session for every new task
- Don't let Claude go on research tangents
- Be stupidly specific in prompts
Three habits for keeping a Claude Code session inside its high-performance zone instead of degrading past roughly 100-200K tokens.
Steal forany long-running AI agent session where token budget is a hard limit
08:51list
Verification methods
- Tests written before implementation, not after
- Type checkers and linters
- Screenshot testing
- Browser testing / computer use
Concrete ways to make Claude check its own work instead of just declaring a task finished.
Steal forany AI coding workflow, front-end or back-end
How they asked for the click.
VERBAL ASK
19:49product
“You can try Brilliant's new tutor for free and get 20% off an annual subscription by scanning the QR code or clicking the link in the description.”
Dedicated mid-roll sponsor read with an on-screen QR code and a worked coding example, framed as a way to actually learn instead of blindly accepting AI output.
MENTIONED ON CAMERA
FROM THE DESCRIPTION
PRIMARY CTAWhere the creator wants you to go next.
AFFILIATECommission earned if you click.
OTHER LINKSAlso linked in the description.
Visual structure at a glance.
