13:10Austin Marchese · Talking Head
Stop Prompting Claude. Start Graph Engineering Instead.
A Stanford-adjunct framework for treating every Claude Code workflow as a graph you can redesign, not a prompt you keep tweaking.
August 20thThe argument in one line.
Hitting a Claude token limit is really a compute-budget problem with two levers, tokens consumed and model used, so the fix is a stack of habits and infrastructure that reduces one or both, from clearing context between tasks up to swapping which model runs your agent entirely.
Read if. Skip if.
READ IF YOU ARE…
- You use Claude Code or Claude Desktop daily and regularly hit session or weekly limits before your work is done.
- You run custom skills, MCP servers, or sub-agents and suspect your context window is bloated before you even type a message.
- You want a concrete, ranked list of fixes rather than a single trick, and you're willing to touch your CLAUDE.md, skills, and hooks.
- You're curious about routing work across multiple AI harnesses (Codex, GLM, DeepSeek) to stretch a fixed subscription budget further.
SKIP IF…
- You use Claude only occasionally and have never come close to a token or session limit.
- You want a single quick fix, not a full audit of your MCPs, skills, and CLAUDE.md.
The full version, fast.
Token limits come from a compute budget, not raw token count: compute budget used equals tokens consumed times model used. Quick wins fix contextual habits (clear/compact between tasks, audit what preloads via MCPs/skills/CLAUDE.md, trim output with a concise instruction). System upgrades compress inputs before Claude sees them (a tool called RTK), and push repeatable sub-agent work onto cheaper "minimum viable" models or plain scripts that cost zero tokens. The riskier "nuclear" tier routes token-heavy execution to Codex (which burns roughly 4x fewer tokens on some tasks because it's built to be surgical rather than thorough), converts bulky text into images before submitting it, or swaps the underlying model entirely for GLM, DeepSeek, or a local model, each with real tradeoffs in quality, privacy, or hardware cost.
Free for members
Chat with this breakdown — free.
Sign in and you get 23 free chat messages on us — ask for the hook, quote a framework, find the exact transcript moment, generate a markdown action plan. Bring your own key when you want unlimited.
Create a free account →Where the time goes.
00:00 – 01:03
01 · Cold open: the token equation
States the three-part structure (quick wins, system upgrades, nuclear enhancements) and the core formula: compute budget used = tokens consumed x model used.
01:03 – 01:55
02 · Part 1: Quick Wins
Introduces auditing your system with /usage to see what's actually consuming your budget before trying to fix it.
01:55 – 03:16
03 · Quick Win 1: Fix Your Contextual Habits
Shows /context filling up from one long message and lists four habits: /clear between tasks, work in focused blocks to keep the cache discount, adjust effort level, and /compact around 60% full.
03:16 – 04:40
04 · Quick Win 2: Contextual Cleanup
Runs /context in a brand-new chat to show 58.8k tokens already preloaded, then gives a copy-paste prompt to audit unused MCPs, trim skill descriptions, and cut CLAUDE.md toward Anthropic's 200-line guidance.
04:40 – 07:14
05 · Quick Win 3: Reduce Your Output Tokens
Recommends adding a "be concise" instruction to CLAUDE.md or installing the Caveman plugin to cut output tokens, then runs a Bolt Slides sponsor read for AI-generated slide decks.
07:14 – 07:25
06 · Part 2: System Upgrades
Transition card into the second, higher-leverage tier of fixes (60-90% more efficient, per the creator).
07:25 – 08:50
07 · Upgrade 1: Compress Inputs Before AI Sees Them
Explains offloading preprocessing to Claude Code hooks (e.g. grep-ing a log for ERROR instead of dumping it whole) and introduces RTK, a tool that compresses tool output roughly 60-90% before Claude reads it.
08:50 – 10:51
08 · Upgrade 2: Subagents on the Minimum Viable Model
Argues for the "minimum viable model" rule (don't use a frontier model for tasks last year's AI could already do) and shows a decision table for setting a skill's model and context-fork settings.
10:51 – 11:51
09 · Upgrade 3: Move Workflows Into Script-Driven Skills
Extends the RTK idea to full scripts: a deterministic script costs zero tokens and never hallucinates, so repeatable steps inside a skill should become code, not another AI call.
11:51 – 12:03
10 · Part 3: Nuclear Enhancements
Transition card plus the video's subscribe/giveaway ask before the riskier, higher-effort fixes.
12:03 – 12:58
11 · Nuclear 1: Route Work to Codex
Compares Codex (~256k tokens/session, resets every 5 hours) against Claude Code (~1M tokens with Opus), and recommends installing a Codex plugin for Claude Code to hand off token-heavy execution since Codex is built to be surgical rather than thorough.
12:58 – 13:50
12 · Nuclear 2: Use Images Instead of Text
Introduces pxpipe, which renders bulky text/context as an image before sending it to Claude, claiming a 60-70% token reduction versus raw text at some accuracy cost.
13:50 – 14:47
13 · Nuclear 3: Swap the Engine Out Entirely
Explains that Claude Code (the harness) and the underlying model are separable via environment variables, and floats GLM's coding plan and DeepSeek as cheaper-per-dollar alternatives with real tradeoffs (data privacy, weaker models).
14:47 – 16:26
14 · Nuclear 4: Run Your Own Model Locally
Weighs running a model on personal hardware: pros are limitless tokens, data ownership, and full stack control; cons are the $10k+ hardware cost, no true frontier model to download, and the burden of managing your own server.
16:26 – 18:06
15 · The Full Checklist (Speed Run)
Recaps all ten fixes in rapid succession across quick wins, system upgrades, and nuclear enhancements, then closes with a related-video recommendation.
Lines worth screenshotting.
- Compute budget used equals tokens consumed times model used, so every fix in this video only ever moves one of those two variables.
- Claude caches a session's context for 5 minutes, which cuts token usage by roughly 90 percent if you keep working instead of walking away and coming back cold.
- One creator found 65 percent of his Claude usage ran above a 150k context window, and 58 percent came from sub-agent-heavy tasks.
- A fresh Claude chat can already be 58,800 tokens deep before you type a single word, entirely from preloaded MCPs, skills, and CLAUDE.md.
- Anthropic's own guidance is to keep CLAUDE.md under 200 lines; anything longer taxes every single message in every conversation.
- RTK is a free tool that compresses tool output before Claude reads it, turning a roughly 15,000-token report re-read into about 1,800 tokens in testing.
- The rule of thumb for sub-agents: if AI could have solved the task a year ago, you don't need a frontier model to solve it now.
- A script that replaces a repeatable AI step costs zero tokens and runs identically every time, unlike an AI call, which can hallucinate.
- On certain tasks, OpenAI's Codex reportedly burns about 4x fewer tokens than Claude Code because it's built to be surgical rather than to re-read and verify at every step.
- Converting a page of text into an image before sending it to Claude can drop a 10,000-token input to roughly 3,000 to 4,000 tokens, per the open-source tool pxpipe.
- Running a frontier open-source model locally can require over $10,000 in consumer hardware just to reach the tier of quality Claude already offers by subscription.
- Claude Code references environment variables that let you swap its underlying model entirely, so the harness and the model are two separate, swappable layers.
Token limits are a budget problem with two knobs, not one
WHAT TO LEARN
Every fix in this video shrinks either the tokens you send or the model price you pay per token, so the real skill is knowing which lever a given task actually needs.
01Cold open: the token equation
- Compute budget used equals tokens consumed times model used, so any fix that doesn't touch one of those two variables won't move your limit.
03Quick Win 1: Fix Your Contextual Habits
- Run a usage audit before changing anything; a lopsided share of usage from oversized context or from sub-agent calls points you straight at the fix that matters.
- Clearing or compacting between tasks protects a roughly 90 percent prompt-caching discount that quietly disappears if you walk away and come back cold.
04Quick Win 2: Contextual Cleanup
- A brand-new chat can already carry tens of thousands of preloaded tokens from MCPs, skills, and a bloated CLAUDE.md before you type anything.
- Keeping an instruction file under roughly 200 lines avoids paying a fixed token tax on every single message in every conversation.
05Quick Win 3: Reduce Your Output Tokens
- Adding a short "be concise" instruction is a low-effort way to cut output tokens, which are usually a small but avoidable share of total spend.
07Upgrade 1: Compress Inputs Before AI Sees Them
- Tools that compress tool output before the model reads it (like RTK) can cut a large re-read from thousands of tokens down to a few hundred.
08Upgrade 2: Subagents on the Minimum Viable Model
- Apply a minimum-viable-model rule to sub-agents: match model cost to task difficulty instead of defaulting every call to the most expensive frontier model.
09Upgrade 3: Move Workflows Into Script-Driven Skills
- A deterministic script replacing a repeatable AI step costs zero tokens per run and can't hallucinate, unlike calling the model again for the same task.
11Nuclear 1: Route Work to Codex
- Different harnesses spend tokens differently on the same task, so routing surgical, well-scoped work to a leaner harness can stretch a fixed subscription further.
12Nuclear 2: Use Images Instead of Text
- Rendering bulky text as an image before sending it can cut input tokens sharply, at the cost of some accuracy on exact text.
13Nuclear 3: Swap the Engine Out Entirely
- The harness and the underlying model are separate layers, which is why swapping models (or running one locally) is possible without switching tools.
14Nuclear 4: Run Your Own Model Locally
- Running frontier-quality models on your own hardware currently costs more in equipment and upkeep than most subscriptions, so it's worth knowing about before committing to it.
Terms worth knowing.
- Token
- The unit an AI model uses to measure text, roughly a few characters. More text in a request or a response means more tokens spent.
- Context window
- The pool of text (instructions, files, prior messages) an AI model can "see" at once. A fuller context window means more tokens consumed per message.
- Compute budget
- The total processing capacity allotted to an account or subscription tier. Hitting a limit is really running out of this budget, not just running out of tokens.
- Prompt caching
- A feature that reuses recently processed context instead of reprocessing it from scratch, cutting token cost by roughly 90 percent if the next message arrives soon enough.
- Sub-agent
- A separate AI task spun off from a main conversation to do focused work, which can run on a cheaper model without pulling in the main thread's full context.
- Hook (Claude Code)
- A script that runs automatically at a point in Claude Code's workflow, for example to filter a long log file down to just the error lines before Claude ever reads it.
- Skill (Claude Code)
- A predefined, reusable task definition that can specify which model to run and whether it needs the main conversation's context or a fresh, isolated one.
- CLAUDE.md
- A project's instruction file that Claude re-reads on every message. A long or bloated one adds a fixed token tax to every single conversation.
- Harness
- The orchestration layer (like Claude Code or Codex) that decides how a prompt reaches the underlying AI model and how it acts on the response.
- Minimum viable model
- The cheapest model capable of completing a given task reliably, used instead of defaulting to the most expensive frontier model for every job.
Things they pointed at.
01:16tool/usage command (Claude Code)
14:15productGLM Coding Plan (Z.ai)
14:18productDeepSeek API pricing
Lines you could clip.
01:16
“Compute budget used equals tokens consumed times model used.”
04:28
“If you have a 4,000 token Claude MD, you start every conversation 4,000 tokens deep.”
09:28
“If AI could solve this task a year ago, you don't need a frontier model to solve it.”
10:50
“A script will run the same way every time, cause zero tokens, and never hallucinates.”
12:31
“Claude is built to be thorough, it re-reads, it verifies, it thinks before it acts, and you pay tokens for every step along the way. Whereas Codex is built to be surgical. Get in, make the edit, get out.”
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'm gonna break down how you can set up Clawd so you never hit a token limit again. The process is broken down into three parts that you can copy. Quick wins, system upgrades, and nuclear enhancements.
But before we get to those fixes, you need to understand how AI token consumption works because a lot of people get this wrong. There are three key terms to understand. Tokens, the model you're using, and your compute budget.
A token is essentially how much text the model has to process. An AI model is what impacts how much compute is used per token. Better models require more compute per token.
And your compute budget is how much compute is budgeted to your account. So Claude Pro, Max, these subscriptions all have an allocated budget you can draw down from. When you run out of tokens or hit a limit, that really has to do with the total compute associated with your account, not necessarily the amount of tokens that you consume.
So with this foundational understanding, if we don't wanna spend more money to increase our compute budget, there are two variables you can play with, the tokens we use and the model we use. A formula I'm gonna be referencing throughout this video is compute budget used equals tokens consumed times model used. Every fix we cover in this video will optimize one of these two variables.
So the first part, part one, which is quick wins, is all about token consumption. To identify some of these simple quick wins, the best thing to do is to audit your system. At the end of the day, you can't solve a problem if you're not sure what's causing it.
So if you open Claude code and you type slash usage, you'll see a breakdown of how many tokens you've used, plus a section called what's using your limits, which is essentially where your tokens are going. This is Claude's way of helping you identify your problems.
Now for me and for a lot of you, you'll likely see two different issues that jump out. The first for me is that 65% of my usage ran above a 150 k context.
And number two is that 58% came from sub agent heavy usage. And we'll cover sub agents later, but for this part, we'll focus on optimizing our context. Context is essentially all of the additional information you provide to Claude to get a better response.
The more context, the more tokens you use, the quicker you reach your limit. So to fix this, you need to set some new habits. So the first quick win is fix your contextual habits.
As conversations progress, your context window will quickly fill up. To show that, on the left, I type slash context in a new chat. And then on the right is my best Bart Simpson impersonation where I sent a long message, which had nothing but adding context a bunch of different times.
And you can see just with this one message that my context more than doubled, which means that my token usage essentially doubled. Now this is with one message. You can imagine how bad this gets over time.
Some good habits to maintain your context is first, whenever you're switching tasks, run slash clear or start a new chat. The second is try and consistently work on projects versus coming back after five minutes. So if you're waiting ten minutes before responding, you don't get that caching benefit.
The third is that you can actually adjust your effort. So no matter what model you use, there is a default effort you can set. Simply put, the higher the effort, the more compute required per task.
To adjust yours, click the bottom right corner on Clawd Desktop, and then it might say low, medium, high, and then you can drag it to whatever effort you want. The fourth is a mid habit as your context window fills up, let's say, 60%. And you can see that in the bottom right corner, the circular icon.
You type slash compact, which will compress everything into a short summary to help you manage your context. And if you are using Claude code directly in terminal, write slash status line so that you can see your context directly on screen. So that first quick win is just improving your habits with all the strategies I just mentioned.
The second is you need to run a contextual cleanup. If you start a new conversation, and then type slash context in a completely fresh chat. This will show you everything that gets preloaded automatically to every conversation you have with Claude.
So for me, you'll see that I've already filled up 58.8 k of my context window before typing a single word. The higher this number is, the higher your minimum token consumption will be for every new conversation.
And so we can actually clean this up so that we're not starting from such a high token count. Here's a prompt to help you do it, but going through it, the first part of the prompt will review any of your unused MCPs and delete them. If you wanna do this manually, you can type slash m c p and you'll see a full list of what you currently have set up.
Next, it will clean up your skills. Every time you start a new session, your skills and their descriptions get loaded into context. So if you have unused skills, just delete them.
Or if your skill descriptions are extremely long, just shorten them. This part of the prompt will help you do exactly that. And then third, this will revise your Claude MD file.
This file gets reread every message for the entire conversation. So if you have a 4,000 token Claude MD, you start every conversation 4,000 tokens deep. The best practice in terms how to structure your Claude MD is you want it to tell Claude how to interact with your specific project.
You don't necessarily want it to have extensive documentation. And a rule of thumb from Anthropic Docs directly is that you wanna keep your Claude MD under 200 lines. Anything longer than that, and you're paying a tax on every single message.
So that'll clean up your context so you're starting at a lower point. The third quick win is reduce your output tokens. The more words that Claude says to you, the more tokens you spend.
Right? These are the response. These are the output tokens.
And this is generally a relatively small amount of your overall consumption, but this is a quick win that I absolutely love. Just paste this or add this to your Claude m day.
Be concise with all of your responses. Or you can go a step further and install a plugin that I love called Caveman. It makes Claude speak like a caveman, and so you can actually see on screen the before caveman and after caveman response.
Those three quick wins are all foundational things that you need to do. But the next section are system upgrades that can make your system up to 60 to 90% more efficient. But before we get to that, one thing I'll spend a lot of tokens on unnecessarily is trying to make decks for my clients, which brings us to today's video sponsor, Bolt, and specifically their new product, Bolt Slides, which has changed how people make decks going forward.
To use it, just go to bolt.new, click slide deck, and type something like, build me a five page deck about AI automation I can build for a client, Builds a real responsive web app styled and structured in seconds. Or you can connect it directly to Claude code and have it generate a deck for you without ever leaving the terminal.
And so, yes, Bulk can make a deck very quickly, but that's not why I like it. You guys know how much I stress the importance of using AI to improve the quality of your outputs, not just do things faster.
And Bolt Slides enhances the deck creation process in three ways. First is you can embed whatever you want into your slides. For example, a live chart with updating data or a clickable diagram.
Honestly, how bangers would it be if you had a product showing real time usage and it's counting as you present. Now, this really unlocks a world of possibilities. Now, the second way is it looks native everywhere.
So whether you're on a projector, a phone, a tablet, it doesn't matter because these slides are a native web app. One of the things that I personally hated when pitching brands like Google and Amazon at my last startup was whenever I shared a deck, I'd have to say, make sure to open this on desktop. And that was just annoying because if they viewed it on their phone, it would look terrible.
But now with both slides, you can view it wherever, however. And the third is speed of iteration allows you to visualize decks as part of the creative process. Typically, when I'd make a sales or an investor deck, it started with a bullet point list.
And then I'd take that bullet point list and then visualize it. And at that point, I'd often realize the concept didn't actually work. But by creating a visualization of these concepts earlier, you're able to streamline the entire process.
Now if you want access to Bolt's new feature, click the link below and differentiate yourself with the next generation of slide decks. Part two, system upgrades. So the first upgrade to your system is compress inputs before AI sees them.
So every piece of text that you provide Claude consumes tokens. So in an ideal world, you would compress the text so it's only sharing with Claude the text that actually matters. To help you visualize this, imagine you're working on a report for a client, and you want Claude to review specific changes.
If you only made changes on the first page, would it make sense to share the entire 10 page report to Claude? No. It wouldn't, but Claude does this by default.
So what you could do instead is use Claude hooks to preprocess these files to be more efficient with tokens. This is pulled directly from Anthropic Docs, it tells you to do exactly this.
It says offload processes to hooks and skills. And then it gives an example of reading a file and only pulling the information that has a prefix text error. Luckily, we don't have to figure out how to do this because there are who have helped us for free.
There's a free open source tool called RTK that will help make the text that's shared with Claude significantly more concise. To visualize where it sits, normally, Claude will read the report.
It'll reread the changes to check the work, and then the full raw output is dumped into Claude. And so let's say this process takes about 15,000 tokens. After RTK, Claude will edit the report.
It'll reread the change to check work. RTK then uses deterministic logic to clean up the text, removes repeated text, boilerplate, formatting noise, compresses the text, and then shares that with Claude.
And that would end up being about 1,800. It's quite genius, and it works for both technical and nontechnical tasks. I ran some tests on my computer across 13 commands, and I was able to save 92% of my tokens.
Now RTK claims 60 to 90%, and the exact savings depend really on what you're doing. But to set this up, you literally can just paste their repo and then say, set up RTK on my project so it runs automatically in the background. Hit enter, and then it'll go through the process.
The second system upgrade is leverage sub agents with reduced models. Let's go back to the equation we had earlier. Compute budget used equals tokens consumed times model used.
Thus far, we focused on tokens consumed. But what about the model that we actually use? The reality is if you can get a task done with Haiku instead of Fable, you save 90% of your compute budget.
So the general rule of thumb in your brain is if AI could solve this task a year ago, you don't need a frontier model to solve it. Scraping, summarizing, formatting, fetching files, none of that needs the frontier models that are getting released. This framework is what I call using the minimum viable model.
So how can we do this in practice without overengineering our system and pulling our hair out? What we do is we predefine the model we use inside Claude skills.
Skills are predefined tasks that you use over and over again. So once you define the minimum model for that skill, it will use that model for all future runs.
And when setting it up, there are two variables you can play with, context and model. Model, you specify the model that you want to use for this specific skill and then the context. If you don't need to have contextual information, you can say context fork, which will create a new thread for that skill to work on, in turn reducing the contextual information that's needed.
If you do need previous info, you'll just leave that part blank in the skill itself. Here's a table on how to optimize skills based on specific needs. If you're still struggling to visualize why to do this, think of it like a team of lawyers.
You want the partner at the law firm leading the case. But because his hourly is so expensive, you want junior lawyers doing a lot of the simple grunt work. It's the same idea here.
And to find where this applies in your own setup, here's a prompt. Now, that's just one of the ways to upgrade your skills to be more efficient, but the next upgrade is one of my favorites. Upgrade number three, move your workflows into script driven skill.
After you've updated your skills to use a specific model, there is one more step. This one improves quality, consistency, and speed while also reducing token consumption. So a lot like RTK enhancement that uses computer logic to compress text, you can use computer logic or scripts to complete tasks that you're currently using AI for.
So a script will run the same way every time, cause zero tokens, and never hallucinates. So in an ideal world, we wanna use AI for judgment and then scripts for everything else that's repeatable. This way, AI doesn't have to refigure out something every time you do it.
Here's a prompt that enhances your skills to leverage scripts and flags any skill your project is missing. Now before we get to part three, which walks through nuclear enhancements, if this is your first video of mine, welcome to the channel.
But if this is your second or more, you know the drill. This is our anti SLAP agreement. The visuals, the testing, the hours of research that went into this video, this is entirely built for humans, not for these .
Okay? So all that I ask is that you subscribe as part of this agreement, help this content reach more people so that I can just keep doing this. Also, every video I give a clawed max subscription away.
This video's winner is Chad n five n five x who's building a complete AI operating system. Shout out Chad. You are a legend.
Now, if you wanna enter the next giveaway, comment below with what you're building or any recent issues you've run into. And every video you comment on is another entry. Part three, nuclear enhancements.
These are four big changes listed in the order that you should do them. And the last one is going viral right now, but I'll explain why I don't necessarily think it's worth your time. Nuclear enhancement one, route specific work to codecs.
The reality is that certain models are more efficient than other models, but that also extends outside the model layer into the harness layer, the tool that's actually orchestrating using AI. So when you prompt Claude code, the logic that interacts with the AI models is the harness. So Codec's ecosystem, OpenAI's product compared to Claude, on certain tasks, it burns four x less tokens than Claude does.
And the reason for this, to simplify it, is that Claude is built to be thorough. It rereads, it verifies, it thinks before it acts, and you pay tokens for every step along the way.
Whereas for Codex, it's built to be surgical. Get in, make the edit, get out. So to use this to your advantage, you can intertwine Codex and Claude to get the most out of your subscriptions.
The simplest way to do it, and my favorite, is there's a Claude code plugin for Codex. You can install that, then have Claude route any token heavy execution task to Codex. This prompt will help you install that plugin, set it up, and then update your Claude MD to tell Claude to actually do this.
Nuclear enhancement number two is use images instead of text. This one sounds fake, but it's so awesome that I had to include it. So Claude processes images at a different rate than it processes text.
So you can convert text into images and then submit that to Claude to become more efficient with your tokens. Now there's a lot going on there, but to visualize it, imagine you had a massive page of text with over 10,000 tokens. And then an image with that same text, but in image form.
In order for Claude to actually process this image, it only takes 3,000 to 4,000 tokens resulting in a 60 to 7% token reduction. These are based on claims from PX Pipe, the open source tool on GitHub that will help you do exactly this. Now there are some trade offs like it won't read the text perfectly, and there is a non zero chance that Anthropic patches this in the future.
But I found this so damn interesting that I just had to include it. Nuclear enhancement number three, swap the engine out entirely. Most people aren't aware of this, but Claude code is the harness, and the model that's inside of it and is actually used can be swapped.
So for example, you could use Claude code and only use OpenAI or other open source models. Now to actually do this, it's pretty straightforward. There are some environment variables that Claude code will reference to know which model to use, and by default, it goes to Claude's models.
Now, two potential options that are considering looking into are ZAI's GLM plan and the DeepSeek plan. Based on research for these on a compute per dollar spent, these can provide you with more capacity than Claude's plans.
There are trade offs. Right? DeepSeek is Chinese model.
You may be concerned with your data privacy. And also, when you're using these tools, you are getting slightly worse models. Here's a prompt you can use to go down this rabbit hole and learn a lot more.
And as part of that, it'll build you an implementation plan if you want to eject out of the Anthropic ecosystem. This prompt is also designed to help you identify current providers as offers are constantly changing. Now, the fourth nuclear enhancement is running your own model locally.
This is an enhancement that I eventually will fully believe in. It's beautiful. Right?
You can run your own models locally and not rely on external data providers. So for example, I have this Mac mini. It's corner here, can't see it.
But I could run a model on it and then route all of my requests directly to that instead of Claude. So everything is staying within my office, and now there are pros and cons to this. Some of the pros is you can essentially have limitless tokens.
All I have to do is pay for the power to keep the hardware running. Next is that you own all of your data. If data privacy is a concern, this means nothing is exposed to external service providers.
Third, you own the entire AI stack. You aren't reliant on anyone elsewhere. And this concept of running a model locally is why we'll never actually be able to ban AI entirely.
Now, cons of this, first, my Mac mini and then 99% of consumer hardware can't actually run any of the top tier open source models. And in order for you to get to those models, you're gonna have to spend over $10,000. Next is that none of the frontier models like Fable are accessible to download locally, which means you're sacrificing quality in the short term.
And then finally, you have to set up a computer server farm. And as someone who turns his phone on airplane mode at night, I would not want all of that EMF radiation near me. Jokes aside with the EMF radiation, but you have to set up the server farm and you have to manage it.
That's work. So long term, I do fully expect local models to be a thing as hardware gets better and the open source models get better as well. And at that point, it may a 100% be worth it.
But right now, my recommendation for you is you can play around with local models. It's valuable for you to know that it exists, but I just wouldn't go all in on this. So please don't go and buy expensive hardware.
Maybe one day, just not today. So with that being said, let's speed run the changes that you need to make today to get more out of your system. So the first quick win is fix your contextual habits.
Run slash clear every time you switch tasks. Work in focus blocks so you can keep 90% cash discount and set your effort to match the task. And then use slash compact when you get to 60% full on your context.
The second quick win is run the cleanup prompt. Disconnect MCPs you don't use, archive unused skills and shorten their descriptions, and turn your Claude MD into a directory instead of a document. Then make sure your Claude MD is less than 200 characters.
The third is cut your output tokens. Add BeConcise to your Claude MD. Use the k man plugin or update your Claude MD to tell Claude to be concise with all their responses.
Then for the system upgrades, install RTK so every command output gets pressed before Claude reads it. This could reduce your token input by 60 to 90%. Second, enhance your skills so Grunt work runs on minimum viable models instead of your most expensive ones.
The third system update is turn every repeatable step into a script inside the skill. Computer code causes zero tokens to run. Then the nuclear enhancements.
First, route any token heavy execution to codex with the plugin. This is where you could have two subscriptions with two different budgets and more total firepower. The second is use images instead of text.
Keep an eye on this one. The third is that you can swap the engine out entirely if you wanna work with different model providers. And the fourth, as I mentioned, you can run your own local model if you really want to.
Now once you apply this, you'll be able to build all day long instead of having to wait every five hours for your limits to reset. And if you like this video, you will love this video where I walk through my exact setup to leverage Claude's skills to build 10 times faster. This builds on a lot of what I covered in the skill optimization section of this video, and you will love that.
I'll see you over there. Pete.
The Hook
The bait, then the rug-pull.
The title promises a paste-and-go fix, but the video actually opens with a formula: compute budget used equals tokens consumed times model used. Everything that follows, from clearing chats to swapping the model entirely, is just another way to shrink one side of that equation.
Named ideas worth stealing.
01:16concept
Compute Budget Formula
Compute budget used equals tokens consumed times model used. Every fix in the video reduces one of these two variables rather than the compute budget itself.
Steal forFraming any AI cost conversation with a client or team, separate "how much you're sending" from "how expensive the model is"
10:05model
Skill Frontmatter Decision Table
- No context needed, no frontier brain needed -> context: fork + cheap model (full win)
- Needs conversation context, no frontier brain -> model: haiku only (cheap, keeps the thread)
- No context needed, needs frontier brain -> context: fork only (hygiene, keeps quality)
- Needs both context and frontier brain -> neither, that's main-thread work
A 2x2 grid for deciding, per Claude Code skill, whether to fork context and/or downgrade the model.
Steal forAuditing any existing skill or sub-agent setup for wasted spend on frontier models doing simple, context-free tasks
08:22concept
RTK Compression Pipeline
Claude edits a file, re-reads the change to check its work, and normally dumps the full raw diff/output into context (~15,000 tokens); RTK intercepts that output and compresses it deterministically before Claude sees it (~1,800 tokens in the creator's example).
Steal forAny Claude Code, Cursor, or Copilot setup where large tool outputs (diffs, logs, test results) are re-read by the model on every step
How they asked for the click.
VERBAL ASK
04:58product
“Try Bolt Slides today to transform how you make decks.”
Mid-video sponsor read tied to the "reduce output tokens" chapter, with a live demo of generating a deck at bolt.new, then a hard link-below ask.
MENTIONED ON CAMERA
FROM THE DESCRIPTION
PRIMARY CTAWhere the creator wants you to go next.
OTHER LINKSAlso linked in the description.
- Stop coding, use skills instead ↗
- Claude Code vs Codex, which to use ↗
- 9 plugins to build 10x faster ↗
- Free 5-day AI playbook (what I used to build a $25M+ startup) ↗
- Use BuildPartner to build 10x faster with Claude Code (try free) ↗
- Want to build a SaaS product without hiring a CTO? ↗
- Caveman plugin ↗
- RTK ↗
- Codex plugin ↗
- pxpipe ↗
Visual structure at a glance.
