If you're watching this video, then I'm going to guess that you're somebody who's been running into plan limits on your Claude subscription.
Well, the good news for you is that I'm about to show you 11 ways so you can make sure you never run into those usage limits again.
And there's a key fundamental principle that most people totally overlook, and it will change the way that you interact with Claude code forever.
So the first thing which you need to understand is that Claude code does not actually remember anything at all.
So the way this actually works is for every new message you send away to CloudCode, it's not only receiving that latest message, it's also receiving everything prior to that as well.
So if you've had 50 interactions back and forth with CloudCode in your session, then on the 51st message, it's receiving all of that context again.
And you might be thinking, well, that would be chewing through millions of tokens, and it would.
And that brings us on to the idea of caching.
So caching is how Claude Code knows what information already existed in the session versus what is new.
And this is what stops us from burning through our session limit after maybe only 20 or 30 minutes.
So on the first turn, so your first interaction in that session, Claude is going to receive the system prompt, the project context and your initial message.
Then on turn two, Claude knows that all of this information from the first turn already existed.
So all you're going to be charged for on turn two is Claude's response and then your next prompt.
And it's the same for turn three.
It then knows that all of the information from turn two was already there.
So you're only being billed for the new stuff at the end.
And everything which happens before this reply, all of this is known as the prefix.
You'll see in a second why this is so important when we get into the tips.
but for now just understand that if something in the cash data or something in the prefix changes
then you're going to be paying for all of this a second time which means if you have 500 or 600
thousand tokens sitting in your context window and something in the prefix has changed then you're
going to be paying for all of that again. So all of that is to say that Claude does not remember
who you are between turns. Every new message it's sending everything back to Claude again,
it's going to read through it, it knows what was already there, it knows what is new, and you're
only going to be billed full price for the new stuff. Now if you're using it on the API, we know
that cached inputs are 0.1x of the initial input cost. CLODs do not disclose publicly in their
documentation what that multiple is for planned subscriptions, but we do know that we're not paying
full price for those tokens. Again it's going to be some form of fraction of the initial input cost.
Now that we've cleared up that important distinction everything from here on will make much more sense
so let's move into the first tip which is keeping all of your important context inside of your
clod.md file. A clod.md is just a markdown file which lives inside of your project and it gets
auto-injected into your context window at every new session start in that project. So the reason
this is so important is if you're not using a clod.md file then at the start of every new session
you need to explain who you are, what your tech stack is, where your files go, what your rules are
and then you need to give it your task or your initial prompt. Whereas if you are using a clod.md
all of this context is already stored in there so clod already has all of that information.
You're not wasting tokens going back and forth explaining the same thing every time. So it won't
just save you tokens, it will also save you time. You can see my clod.md inside of my project here.
Now if you want to create one, you can run slash command slash init and you can see here,
initialize a new clod.md file with code-based documentation or you can just describe in plain
English that you want it to create you a clod.md and it will go ahead and do that for you. Tip
number two is keeping your context below 20 to 25%. If Opus 4.8 and these other new anthropic
models all have a million tokens of context then why would we aim to keep things sub 25 percent
well there's a multitude of different reasons for this but i'll just cover a couple of them now
and the next three tips after this one are all related back to this same issue so this is very
very important so the first one is as i mentioned in the intro when we send our prompts the first
time around to the clod api in clod code we're being charged 100 of the cost for those tokens
So we're being billed one token for every token. Now after that, once those tokens are
cashed and they become part of the prefix, we're still paying for those tokens. And we
don't know what that cost is for Anthropic subscriptions or Claude plans, but we do know
that those tokens are not free. So even if it's 0.05x of the initial cost, so 1 20th of a token,
if you have 500,000 tokens in your context window, then you're paying 25,000 tokens per turn,
and that's going to be increasing with every new turn just in cached reads. So that's one reason.
Now another reason that you would want to keep your context sub 20% is we know that these models
start degrading in performance the more you start to fill this context up. So what that means is if
you have 800,000 tokens, so 80% of your context window used, then the model is not going to be
performing optimally as it would if we only had 150,000 tokens in that context window. You can
see down here in my status line that I have my context usage as a bar and a percentage listed
there which means I can always see it at a glance. Now I would recommend that you do the same and I
will put a prompt on screen which you can copy and give to Cloud Code so that it can implement
the same thing for you. If you want to keep an eye on your context just run forward slash context
and it will bring up this visual where you can see what you've used. You can see it broken down here
on the right hand side as well and it breaks it down below. When you start approaching that
20 to 25% limit, I recommend that you ask Claude to generate a handoff file, which is just a markdown
file with a summary of everything you've done in that session, and also give you a session resume
prompt. So you can then give that session resume prompt back to Claude in the new session, or after
you've cleared your context, have it read the handoff file, and you can pick up exactly where
you left off. And if you want to go one step further, I built this into a skill, I just called
it handoff so all I need to do is run forward slash handoff and it will do all of that for me.
If you want access to the skill you will find all of the resources from the video in the pinned
comment down below. Tip number three is making sure that you keep your prompts within one hour
of the previous prompt. This is one of the simplest and most common mistakes that I see people making
inside of Claude Code and it will chew through your five hour session limit and your weekly quota
on your Claude subscription. So we're looking at the Claude Code documentation here and you can see
that it says Claude Code requests the one hour TTL automatically. So we're talking about the
caching again here. So when you use Claude Code, every time you send a new message away, that
resets the one hour cache. Now if you go out with that one hour, then the cache is then invalidated
and your next prompt, you're going to be paying for all of those tokens again. So if you have
500,000 tokens sitting in your context window, which you shouldn't have if you're following step
two, then if you go away for an hour and you come back, you send your next prompt to Claude,
you're paying full price for those 500,000 tokens again. If you then go away for another hour and
come back and then send your next prompt, you've now paid for those 500,000 tokens three times.
So this is why it's super important that you keep it within an hour of your previous prompt
and going back to the previous tip that you keep your contacts below 20%
so if you do go out with that hour you're not burning 500,000 tokens every single time.
model mid-session. How many times have you heard that you should be changing your model from Sonnet
to Opus for more complex tasks and then back to Sonnet again for the easier stuff? And I'm going
to tell you now that that is bad advice. We're staying inside of the Cloud Code docs and you can
see here actions that invalidate the cache. Number one on the list is switching models. So if we
scroll down you can see that it says each model has its own cache. Switching with forward slash
model means the next request reads the entire conversation history with no cache hits even
know the content is identical. So I see people making this mistake all the time. They're constantly
switching models between Opus, Sonnet, Sonnet, Opus, maybe Fable, and you're paying for all those
tokens again every single time you make that switch. I'm not saying that you should not be
switching models at all because that is genuinely good advice to use the right model based on the
task at hand. What I am saying is that you should not be switching model mid-session. You should be
putting together a plan using your higher power model, whether that's Opus or whether it's Fable,
and then once you have a structured plan in place, switch your model down to whatever it is that
you're going to be using to execute that task, and do not switch again unless you absolutely
have to. Number five is almost identical, and that is avoiding changing effort level
mid-session. Right below switching models and actions that invalidate the cash, we have changing
effort level. So you can see here that it says that the cache is keyed by effort level as well
as model so switching with forward slash effort means that the next request reads the entire
history again with no cache hits. So this is the exact same as the previous tip if you can avoid
changing effort level mid-session then you should absolutely be doing that. Number six is building a
proper memory system. I have a full video on my channel breaking down how you can set this system
up for yourself. I'm not going to go too deep here but I will link that video on screen. But what
we're talking about doing here is building a proper memory system so that Claude Code has a
working map of our project and it always knows where to go to find the information that we're
asking for. And we can do that by using something like Obsidian. And if you don't know what Obsidian
is, it's just a software that allows us to view and edit marked-in files. And you can see here an
example of my obsidian knowledge graph you get this really cool graph we can kind of like pull
around all these different nodes all these different lines that you see are connections
between different documents so it can piece together different bits of information work
between different documents to find the right information to give you a high level overview of
how this works we create a folder somewhere on our computer and we then point obsidian at this
folder and then that then becomes our vault now once we have our vault we can then point cloud code
at this vault and inside of our vault we will have a bunch of different folders in there. Now these
folders can be whatever you like. For me I like to split this into three separate layers. So the
first layer is my working folders. So for me that's things like agency, school, content and inside of
these folders I will have subfolders. So for agency that will be things like clients, it could be
deliverables, outreach, pipeline, for school, it might be frameworks, strategy, courses. So that is
our first layer, all of the working files that you'll be in there messing around with on a day
to day basis. The second layer here originates from Andre Carpathie's Obsidian RAG system. I'm
not going to go into that here so make sure you check out that video linked on screen if you're
interested in that. And the third layer is our clod.md. So in there as we covered in tip number
one. This is where we store our project map, our rules, our context, so that Claude knows everything
which it needs to know about us at session start without us having to explain every time. So how
that relates to our memory system here is, first of all, we give Claude a map of the project folders,
what's contained in each folder, so that it knows where things are. Then we need to give it a map
of where it needs to put things when we ask for them to be saved. So you can see here, anything
for a client goes in agency clients and then the client's name. If it's an idea or a script or a
hook it goes in content. So we give it the information which it needs so that things don't
get lost when it saves them. And finally we give it the knowledge base rules. So this is how it
knows how to operate our knowledge base system and this is arguably the most important part.
You can see here we have information on wiki links to make sure that it's always creating
those links between different documents and that is how we get our nice graph here inside of
obsidian.md. Number seven is creating custom skills. This one is hands down the most powerful
tip in this video, not only from a token saving perspective, but also in maximizing the value
which you get out of cloud code for you specifically. So creating a custom skill is just packaging up
some amount of rich information on a specific topic that's specific to you so that it's repeatable
and Claude can do it over and over again without us having to go back 20 different times, change
this, change that, because Claude already knows what a good output looks like. Now I would highly
recommend that you install the skill creator skill by Anthropics. This is an official Anthropics skill
and it tells Claude Code how to build custom skills. So first of all you're going to explain
what it is that you're trying to do. Then Cloud Code is going to ask you a bunch of questions,
it's going to test it, it's going to run evaluations, it's going to make sure that it
triggers when it should, and it's going to make sure that you're happy with the output. So then
all you need to do when you want to use it going forward is run a slash command and then that task
is now repeatable on the mat. So the reason that this is so powerful is without a skill, you ask
it to do something, you then have to go back saying no that's not right, you might need to go back
again and again and again and eventually you will have a product that you're happy with but by that
point you've burned a bunch of tokens and if you're doing this multiple times a week then I can
guarantee you're wasting a huge amount of your plan limits on tasks that are repeatable. So what I
would suggest is that you copy the prompt which you see on screen and you have Claude go through
your last 10, 15, 20 sessions and pick out things which you've asked it to do multiple different
times and tell it to build those into skills. To install the skill creator skill just run
forward slash plugins and then on the discover tab here you will see it listed fourth from the top.
You can see skill creator create new skills, improve existing skills and measure skills as
well. So all you need to do is enter this and install it. I would recommend that you go for
user scope which means you'll have access to across all of your different projects.
Number eight is using Caveman.
Caveman is a plugin that makes Cloud Code less verbose.
So we know that these large language models love to talk.
You ask it a simple question and it gives you a huge reply,
which will take you five minutes to read.
And Caveman was designed to try and stop that from happening.
And it actually does a very, very good job.
I've been using it on and off now for around about three or four months.
And it is very effective,
especially if you're not wanting a big walls of text back from the model.
So it says here, why use many token when few do trick?
And that is kind of how it works.
Make your AI coding agent talk like a caveman.
Same answers, up to 65% fewer output tokens.
Now for me personally, I probably haven't seen as much as 65% fewer output tokens,
but it does definitely reduce the token output.
You can see an example here.
I said, explain how prompt caching reduces cost in LLMs.
and this was the response that I got using Caveman.
Now if we compare that to this other terminal,
I gave it the exact same prompt,
explain how prompt caching reduces cost in LLMs,
and...
reduces cost in LLMs and the response which I got from this one was much much longer. You can see
the difference here in the size of the response. So this is definitely one that you should be trying
out. Number nine is using ponytail. This one has been blown up over the past few weeks. You can see
that it's number one repository of the day and of the week and it was designed because these AI
coding agents love writing unnecessary amounts of code and ponytail is essentially designed to make
your AI coding agent as lazy as possible without making it complacent. So if we look at the
benchmarks here you can see the impact which this has. So this is versus a no skill baseline,
minus 54% on lines of code, minus 22% on tokens, minus 20% on cost, and minus 27% on time. And if
we keep scrolling down here, you can see this hierarchy of how it works. So before writing any
code, the agent will stop at the first rung that holds. The first thing which it's going to do is
check, does this even need to exist? Only if that is a yes, is it then going to see if there's
something already in the code base that can handle it. And if that is a no, it's going to see,
can I handle this with one single line of code? And only if that is a no, is it then going to
write the minimum amount of code to get the job done. Number 10 is using the Codex plugin for
CloudCode. This is an amazing plugin if you're someone who's already paying for an OpenAI
subscription. So it allows us to use Codex inside of the CloudCode ecosystem, which means we can
offload tasks from the Anthropic models onto the GPT models. Now we know that these GPT models are
substantially cheaper than the Anthropic models and they're now very very competitive as well.
GPT 5.6 has just been released so that is definitely something that you can take advantage of
if you're already paying for an OpenAI plan. Once you have the plugin installed just do
forward slash codex and you will see all the different slash commands which you now have
available. One which you should definitely check out is Codex Adversarial Review, which is going to
have the Codex agent do a deep dive into your code base to see if it can find any security
vulnerabilities. This is definitely one that you should check out. Go in there, have a play around
with it, and this will save you a bunch of tokens. And finally, tip number 11 is offloading research
heavy tasks to Google servers using Notebook LMPi. Notebook LMPi allows us to use Google servers to
carry out any kind of deep web research. We can also use it to generate infographics and slide
decks and a bunch of other cool stuff as well and we can do this all from the command line
inside of Cloud Code. Now one of the main benefits of this is that we know that research flows,
sub-agents, agent teams, all these things are super token heavy and we don't really want to
be chewing through our Cloud subscription on those tasks and that is when we can offload those tasks
to Google servers essentially for free using Notebook LMPi and one of the massive benefits
to this is because it's Gemini under the hood it has access to all of the YouTube content
transcripts and all of that rich information which you normally would not be able to surface
just using Claude Code alone. So I asked Claude Code to use the Notebook LMPi CLI to carry out
research on GPT 5.6 SOL versus Claude Fable 5 and then turn that into an infographic. So it went
through the process here and this is what we got at the end. Now bear in mind I did not need to do
anything for this. I did not use any of my clod tokens or my plan limits and this is what we got
at the end. So this is an awesome tool and you should definitely be leveraging this to save
yourself a bunch of tokens. That is everything for this video today. If you got some kind of
value out of this then please hit subscribe. I would massively appreciate it and make sure that
you check out the pinned comment for all of the free resources. You'll also find a full clod code
masterclass in the school which will take you from complete beginner to proficient
cloud code user so thanks for watching i'll see you in the next one