24:23Mark Kashef · Tutorial
Master All 5 Layers of Every Agentic OS
A 24-minute Earth-layers framework for building AI operating systems that don't decay.
June 30thThe argument in one line.
Effort level is not a proxy for model intelligence, so defaulting to extra-high or max settings on every task wastes tokens without improving the output; the fix is picking the model first, then starting at low effort and climbing only when the result is underwhelming.
Read if. Skip if.
READ IF YOU ARE…
- You use Claude, GPT, Grok, or Gemini regularly and default to the highest effort or thinking setting out of habit.
- You build with Claude Code or Codex and want to control token spend without sacrificing output quality.
- You're confused by the growing number of effort tiers (low/medium/high/extra-high/max) across different AI providers.
SKIP IF…
- You already have a deliberate, evidence-based process for choosing effort levels per task.
- You're looking for a review of a model's raw capability rather than how to tune its settings.
The full version, fast.
Every AI provider now ships an effort or thinking dial (low through max), and most people treat higher effort as a proxy for a smarter model. It isn't. The creator argues intelligence is a model choice, not a dial setting, and effort should be tuned per task after the model is picked. He demonstrates this by running the same coding prompt across 12 effort levels on Claude Code and Codex: the visual and functional differences between low and max are mostly negligible, while max can cost 4-5x the tokens for cosmetic changes like a favicon. His framework: start low with a frontier model, climb only on evidence, and reserve extra-high and max for long, unattended, high-retry-cost tasks.
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:02
01 · The effort trap
Cold open framing the core myth: more effort does not mean a smarter model, illustrated with GPT 5.6's 18 tier/effort combinations.
01:02 – 02:07
02 · The slot machine habit
People pick effort levels the way they'd pull a slot machine lever — by name, not evidence — and default to the top of the range out of habit.
02:07 – 03:11
03 · What level to use when (short version)
Cheat sheet: low/medium for everyday tasks on frontier models, high is the overused provider default, extra-high/max are for rare long-running jobs.
03:11 – 04:00
04 · When high effort backfires
An overstudied-exam analogy explains how pushing effort too high can talk a model out of a correct first answer and into a worse one.
04:00 – 05:23
05 · Pick the model first, then the effort
Sequencing rule: choose Sonnet, Opus, or a frontier model like Fable 5 for the task's complexity, then default every one to low effort and climb only on evidence.
05:23 – 06:37
06 · The brain in a jar (harnesses)
A model has no hands until a harness (Claude Code, Codex) gives it tools; a cited Google paper credits the harness, not the model, with most of an agent's apparent capability.
06:37 – 07:18
07 · Why effort levels differ across providers
Tiers aren't standardized — Grok offers few levels, OpenAI more granular control — so the same label means different things across providers.
07:18 – 09:04
08 · Every effort level, visually
A speed-run through low, medium, high, extra-high, and max, describing the growing token spend and behavior at each rung.
09:04 – 10:33
09 · The experiment: 12 runs, one prompt
Setup for the head-to-head test: an identical self-contained build prompt run across every effort level on Claude Code and Codex, no clarifying questions allowed.
10:33 – 11:46
10 · Claude Code results, low to max
Low is missing data points, but visible gains beyond medium are mostly cosmetic — a favicon appears at extra-high.
11:46 – 14:01
11 · Codex results, low to max
Low already looks close to Claude Code's high; the jump from high to max adds mostly cosmetic changes for several times the tokens.
14:01 – 15:37
12 · The framework for any new model
The decision tree distilled: know-what-done-looks-like → low; normal work → default/high; unknown unknowns → high/extra-high; long unattended retry-costly work → max.
15:37 – 16:17
13 · The free effort decoder guide
Closing CTA pointing to the free effort-decoder guide and the creator's paid community.
Lines worth screenshotting.
- Effort level is not a proxy for model intelligence — a smarter model on low effort often beats a weaker model on max.
- GPT 5.6 alone ships 18 possible model-and-effort combinations across its Luna, Terra, and Soul tiers.
- The average provider defaults new users to high effort, which one creator calls 'bringing a nuclear bomb to a fistfight' for most tasks.
- Running the same coding prompt across 12 effort levels on Claude Code and Codex produced nearly identical dashboards — the differences were cosmetic, like an added favicon.
- Max effort can burn 4-5x the tokens of medium for a slight or even worse output, similar to an over-thought multiple-choice answer changed from a confident right guess to a wrong one.
- Anthropic, OpenAI, xAI, and Google each name and default their effort tiers differently, so 'high' on one provider doesn't mean the same thing on another.
- A Google paper is cited claiming the harness — not the model — accounts for roughly 90% of what makes coding agents feel capable.
- The rule of thumb: pick the model first, start at the lowest effort level, and only climb the ladder when there's evidence the result is underwhelming.
- Extra-high and max effort levels are meant for long, unattended tasks with high retry costs — not everyday work like renaming a UI button or formatting a document.
- On low effort a model uses a small thinking budget and takes the first workable result; on max it plans, executes, and re-evaluates multiple paths, often past the point of usefulness.
- Codex's low-effort run looked comparable to Claude Code's high-effort run on the same prompt, showing default effort behavior differs by provider, not just by tier name.
Effort level measures token spend, not intelligence.
WHAT TO LEARN
The right amount of reasoning effort depends on the task, not the model's ceiling — pick the model first, start low, and only climb the ladder when you have evidence a result is underwhelming.
01The effort trap
- Higher effort settings are not a stand-in for a smarter model — a frontier model on low effort regularly beats a weaker model cranked to max.
- GPT 5.6 alone offers 18 combinations of tier and effort level, which is enough choice to make most people default to guessing.
02The slot machine habit
- Treating effort like a slot machine — picking 'high' or 'extra high' because the name sounds more capable — is a habit worth breaking; the label describes token spend, not intelligence.
- As new model generations ship, it's tempting to default to the top of the effort range, even on frontier models that don't need it.
03What level to use when (short version)
- Use low or medium effort for everyday tasks, especially on frontier models — that's where most real work fits.
- Providers typically default new users to 'high,' a workable but unnecessarily expensive zone for most tasks.
- Extra-high, max, and similarly named top-tier settings are built for long-running tasks that need reflection at every milestone, not daily work.
04When high effort backfires
- Overthinking a simple task with a high effort level can behave like a student who second-guesses a confident right answer into a wrong one.
- Roughly eight out of ten tasks don't need extra-high or max effort, and pushing them there can produce a worse or over-engineered result.
05Pick the model first, then the effort
- Decide the model family before the effort level: Sonnet for straightforward generation work, Opus for deeper logic and debugging, a frontier model like Fable 5 for genuinely complex problems.
- Default every model to low effort first, then climb to medium or high only after comparing outputs and finding low underwhelming — the calibration period takes about an hour.
06The brain in a jar (harnesses)
- A language model by itself is 'a brain in a jar' — no hands, no file access — until a harness gives it tools.
- A cited Google paper credits the harness, not the model, with as much as 90% of what makes an agentic coding tool feel capable.
07Why effort levels differ across providers
- Effort levels aren't standardized across providers — Grok offers only a few tiers while OpenAI exposes more granular control, so 'high' on one platform isn't 'high' on another.
- How well you prompt, plan, and spec a task matters more than which effort tier you pick; the gap between tiers shrinks the better the brief.
08Every effort level, visually
- On low effort a model uses one or two tools quickly and takes the first workable result — fine for predictable, low-risk, start-to-finish tasks.
- On medium, a model spends more of its budget double-checking its own path and reconsidering an earlier choice.
- On high, models often plan, check the plan, execute, then verify — the biggest visible jump in token usage happens between medium and high.
- Max effort plans, executes, and evaluates many possible paths, capable of burning an entire token budget on one or two prompts for a small quality gain.
09The experiment: 12 runs, one prompt
- The 12-run test held the prompt, tools, and credentials identical across Claude Code and Codex — the only variable that changed was effort level.
- The test task explicitly forbade clarifying questions, forcing each run to make its own judgment calls end to end.
10Claude Code results, low to max
- Claude Code's low-effort run produced a working dashboard with no scored data points at all, a real capability gap versus medium and up.
- Going from high to extra-high on Claude Code added essentially one visible change — a favicon — a token cost unlikely to be worth it for most tasks.
11Codex results, low to max
- Codex's low-effort run looked and scored comparably to Claude Code's high-effort run, showing default effort behavior differs meaningfully by provider, not just by tier name.
- Between Codex's high and max runs the only visible difference was a favicon and a denominator added to a score, for four to five times the token spend.
12The framework for any new model
- The decision tree: if you know what 'done' looks like, start low; for normal daily work, default or high is enough; for unknown unknowns, move into high; reserve extra-high for long, unattended, retry-costly tasks.
- Running several medium-effort prompts that check and correct each other can reach the same output as one extra-high prompt, for a fraction of the tokens.
Terms worth knowing.
- Effort level
- A setting (low, medium, high, extra-high, max, or similar) that controls how much a model 'thinks' before answering — more effort means more reasoning tokens spent per response, not automatically more raw intelligence.
- Reasoning effort / thinking budget
- The term some providers use for the same effort dial — how many tokens a model is allowed to spend reasoning before producing its final answer.
- Harness
- The surrounding tooling (like Claude Code or Codex) that gives a language model the ability to read and write files, run code, and take actions — the model itself has no hands until a harness gives it tools.
- Frontier model
- The newest, most capable model release from a provider — often capable enough to do on low effort what an older or smaller model needs high effort to match.
Things they pointed at.
Lines you could clip.
01:01
“A lot of people think that effort is a proxy for raw intelligence. So if you set your effort to ultra high, you must be getting the smartest model in the world. In reality, this isn't the case.”
02:30
“This is still the equivalent of bringing a nuclear bomb to a fistfight.”
03:52
“Sometimes you wanna hire the most competent, lazy person to come up with the path of least resistance.”
05:20
“Whatever language model you choose is purely a brain in a jar—it's solely a model that has input text come in and output text, images, video come out.”
15:02
“An extra twenty minutes of your time isn't worth a hundred thousand, a million tokens to spend on the exact same outcome.”
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
00:00Every single month, we get a brand new set of models. And with these set of models, you always have to navigate the spectrum that's called effort. And even with the newest of models, let's take the GPT 5.6 family of Luna, Terra, and Soul.
00:13They have six sets of effort per tier of model, which gives you 18 possible combinations for any given task. And naturally, this becomes confusing. When do you use what kind of effort for what kind of task?
00:26And there's even a bigger issue, which is a lot of people think that effort is a proxy for raw intelligence. So if you set your effort to ultra high, you must be getting the smartest model in the world. In reality, this isn't the case.
00:39So the goal of this video is very simple. I wanna give you hyper clarity on what effort is, how it works, and how you can reverse engineer the best effort level for whatever model you're using even when new ones come out. And near the end of this video, to show you the nuances of using effort in your day to day work, I'm gonna show you one simple task that I executed across 12 different effort levels across two different providers.
01:02So if you wanna focus your efforts in the right place, then let's dive in. Alright. So I'm gonna break this down as simply as I possibly can.
01:08The way that people deal with effort is kind of like a slot machine where they will take a given task and just look at the names of the levels and assume maybe I'll just use high on this or extra high. And medium sounds like it will do a worse job. Kind of confusing this effort level for a proxy of how smart the model will be on a particular task.
01:28So as new models come out, you start building a bad habit where you always assume you wanna live on the right hand of the spectrum. And just as our primary example here, I'll use Claude's effort levels even though I will touch on other model providers as well. You will live typically on this side of the spectrum and never even risk using low or medium even though depending on the type of model.
01:49Let's say it's a frontier model like a Fable five, like a GPT 5.6 Soul. It might make sense to use the low level because the model leap itself in its model weights and training has advanced so far that it's much better than its lower competitor model right below it on extra high.
02:06If you want the short summary of what effort level to use when, you can think of using low and medium on everyday tasks, especially if you're using a frontier model. So if you use Fable, I use Fable a lot on low effort mode because that is more than enough firepower to do the majority of tasks.
02:21The average model provider will set whatever language model you're using to high, which is a default zone. It's a decent zone, but even then for the majority of work that I see people doing, you don't need this. This is still the equivalent of .
02:35So you absolutely can steer clear of this for the majority of tasks. If you don't believe me, like I said in the intro, I'm gonna show you a task I executed where the differences between the effort levels will be negligible. And when it comes to effort levels like extra high, max, heavy, super deluxe, whatever the name is, These are effort levels that you rarely ever wanna use because they're designed for extremely long running tasks where there is nuance, where there's a need for reflection at every milestone of that task.
03:03And I can tell you from experience from teaching entrepreneurs all the way to enterprises that eight out of 10 tasks don't need this level of effort. And not only are these effort levels potentially not needed, but they can actually backfire on you.
03:15If you don't believe me, let's take a simple example. Imagine that you've studied for an exam and this is a multiple choice exam with a b c and d and you've gone through your answers so many times they start to overthink what the answer is. You have so much of a thinking budget even though you're pretty confident based on the simplicity of the question that it's b but you overthink to the point where now you select d.
03:38Many times, if you use extra high, max, ultra, whatever unnecessarily, you'll end up using an effort level that thinks way too much about a very simplistic task. And like many people say, sometimes you wanna , lazy person to come up with the path of least resistance.
03:55You might come into many scenarios where these different effort levels end up over engineering a solution that could be way simpler. Now my approach is to be extremely intentional with first picking the right model, then within that model family what effort level makes the most sense. And if we start from left to right, I will start with Sonnet on low or medium for the majority of tasks like changing the color of a UI button, changing the route that it goes when I click on it.
04:21Excel files, doc files, PowerPoint files, anything that is generation based can be executed by Sonnet. If I feel like I need a much smarter model because I'm dealing with a more complex problem, I want a deeper level of analysis, then opus could make sense. But I'll start on low, and only if low is underwhelming me will I go up in that chain.
04:40So I'm very intentional about starting at the lowest level, then comparing the output to medium and high level. And once I understand the rhythm of that model, which honestly wouldn't take you more than an hour to understand, and if you don't wanna spend that hour, I have another trick I'll show you later on that you can use to expedite this.
04:57But once you settle on exactly what model to use when, then the effort level becomes much easier to use. And lastly, if I feel like I have a very complex problem where it's worth the time, tokens, and money to use something like a frontier model like Fable, then I'll use it on low effort again and I'll only climb that effort ladder if I have evidence that I need more firepower.
05:18Now before I break down each effort level and what it looks like one by one, I want to first talk about harnesses because the average person doesn't realize that whatever language model you choose is purely , and that brain in a jar has no access to the outside world, the ability to manipulate your files.
05:36It's solely a model that has input text come in and output output text images video come out. And by the way, if you enjoy the way I teach and break down these concepts, then you want to check out the first thing down below for my early adopters community. I drop a brand new module every single week in my Cloud Code Living course that's designed to either demystify something that's confusing or give you way more leverage for the same input.
05:57So if that sounds interesting, check it out and maybe I'll see you inside. Alright. Back to the video.
06:01So whatever the frontier model is, it's always gonna be a brain in a jar that needs its limbs to be able to edit your files, run the code, create brand new files, spin up a local server, and actually see how it looks like, which is why Google released the paper a few weeks ago that said that the importance of the model is only 10% of the process.
06:2190 is the harness. And even if it's 80% or 70%, the majority of the magic that you see in these Claude codes, codexes is the harness itself.
06:32The model is what regulates what tool, what limb should be activated for this specific task. And one important concept to keep in mind is that the same way that you can't have two models be exactly the same in behavior, you can't have effort levels mean the same thing across different providers.
06:47Each one will behave very differently because it's effort based on how smart that model is in that model family. So with Grok, you have only a few levels to pick from, whereas OpenAI is designing in a way that you have more control to pick from different tiers of effort level.
07:03But you'll notice that depending on how well you prompt, plan, and spec, whatever it is you're trying to build, the differences between each level is negligible. The most noticeable differences you'll find are typically between low and medium and medium and high.
07:16Now let's do a speed round through every effort level visually so you can see all the nuance differences. So if we take low for example, you can start off with a basic prompt and it would be given a small thinking budget. Meaning, it will only want to use one or two tools, use them very quickly, and take the first result as the answer.
07:33And for tasks that are going from a to b, where like I said, you can predict all the tasks that are needed to be done and they're very straightforward tasks with little to no risk of error, this is more than fine. When it comes to medium, you might have that exact same prompt, but it will use more of a token budget. And in this case, it's helpful because it might check its work and decide, you know what?
07:54I took path a, path b might have made more sense. So it will ruminate over its output and think about what is the best path it should have taken or whether the path it took was the best one.
08:05When it comes to high, this is where you start to see the most stark differences in token usage. And for tasks that need it, it's fantastic. It will sometimes force the model to come up with a plan, then check the plan with you, then execute the plan, then double check whether it executed it in the path of least resistance.
08:22And then we start entering what could be the dangerous territory where you have the model plan, execute, but then over evaluate all the possible options it should take or it should have taken.
08:32So instead of path a versus path b, you could see it go through path a, b, c, and d for what could be a pretty straightforward task. And if you want to evaporate your entire token budget in one afternoon, possibly with one to two prompts, you would use max level where it will plan, it will execute, it will think of many possible paths and many possible futures, you could get to a point where you're overflowing thinking.
08:56You are spending double, triple the token amount of medium for a slight improvement in the final output. Now I've walked you through this conceptually, but I wanna show you an actual task that I executed on Claude code and codex on every single effort level and you'll see the results of all of them.
09:14And you'll be surprised at how similar they are. And after that, I'll give you a little mental model cheat sheet that you can use to navigate effort levels no matter what new model comes out. You take a look at the left hand side, you'll see I have a variety of different terminal sessions each of which running at a different effort level and all of them were given the identical prompt.
09:33So in this case, the prompt is the control group. I asked it to build a complete working project in a new folder called model pulse. And to avoid it asking me clarifying questions, I told it don't use things like the ask user input tool or the equivalent in codex.
09:48So it was given this self contained prompt, and the whole point of it was to make a dashboard that could pull the latest posts from people on x to decide what is people's sentiment towards Grok, Codex models, Claude code on this particular day. So it's basically like a stock sentiment tracker, but for model providers.
10:05And below this initial prompt, there's actually a lot more detail going into what skills, MCPs, and APIs all of these models can access that have all my credentials, which is why I'm not showing you. But you can rest assured that all of them have been given enough instruction on exactly where to pull data, how to visualize it, and what my expectations are.
10:24And I ran this ahead of time so I can show you the nuance differences between each level and tell you behaviorally where they made mistakes. So starting off with Claude Lowe, it put together this thirty day sentiment dashboard that doesn't have any points on it.
10:37Then it came up with these scores and at the bottom, it has a series of posts that are meant to support each one of these scores. If you go from this one to medium, you'll see at least this has some points.
10:48The scores look very similar. It has a better organized set of receipts, but the core nuance here is just the identification of the points on the dashboard itself, but still not great. The next, if we go to high, we still have the points, and now we have some nuance here where it's thinking of is the sentiment going up or down because before it was kinda like this arbitrary number.
11:08You don't know is point o six good or bad. Now if we move from high to extra high, you'll notice one core difference, which is it added a favicon. So you wanna ask yourself, is going from extra high to high worth the tokens to just be mindful enough to add this favicon?
11:24Then as you go down, we have the same point. These scores are a bit bigger, same format as before, and the formatting of the tweets themselves has been adjusted again. Whether it's good or bad, you can see before we had some color coding for top positive and top negative.
11:40If we go to medium at the bottom here, we had green and red. Now we lost that. Then moving on to codex.
11:46If we start at codex low, you'll notice immediately this has a newspaper look and feel. The dashboard looks identical to Claude code on low mode. The scores themselves look pretty good.
11:57They actually look better than all the way up until Claude code on high level. The posts themselves are aesthetically pleasing. So that looks pretty good.
12:04We go to codex medium. We randomly have a text change where now we have an overlap of the l and the s. The dashboard looks identical.
12:12The scores look if anything less good. We have the receipts here that again don't look as good as before, but we have the plus and the minus coloring, which is fine. Now moving from medium to high, you have the exact same text at the very top.
12:25The dashboard looks very similar, although it has more of a neo brutalist look, this little backdrop right here. And you have this random doughnut chart appearing in the scores for no reason. The receipts look a lot better.
12:38Sure. Again, more neobrutalist. So this is something that you could have accomplished on Medium by just saying that you wanted it.
12:43In this case, you're just relying on the model spending and spinning on more tokens to get the same outcome. And if you go from high to extra high, the text looks a little bit different.
12:55The dashboard is pretty much the same. This looks, if anything, worse than before. The receipts look worse than on high mode.
13:03And if we go and finish off with max, what's the core difference you notice right away? Similar to max and high in Claude code, you get this favicon. So you wanna ask yourself, this versus this little shadowing of the text, is this really worth double or triple the amount of tokens?
13:20And now we're showing the score out of one. So we know the denominator, which doesn't really add much.
13:26The posts look very similar back to medium level or high level. So hopefully, this shows you and gives you a pulse that if we gave it a better prompt that said, this is exactly what I want, we didn't have to spend all the same tokens to get pretty much the exact same looking dashboard with some aesthetic differences across the board.
13:44Functionally, there's nothing that is more novel, more insightful about one chart versus the other. It's all these slight nuances.
13:51So spending tokens and way more time doesn't necessarily generate a better output. Now ending off, I wanna give you a framework of how to think through using the right effort level at the right time. So from left to right, if you know what done looks like, it's very clear.
14:05The series of steps need to happen, you can always start off with low, especially if it's a more front frontier model. So let's take GBT 5.6. You would use sole on low effort and see how well that would do.
14:16Then only if more usage is required or more bandwidth is required, would you go up to medium? And then you go up from there. If you have normal daily work, then the default medium or high on a standard model or high level model is more than fine.
14:30Once you get into the areas of unknown unknowns, it might make sense to go into the highs. And if you have a very long running task that really needs introspection through every single milestone that it goes through, then extra high might make sense once in a blue moon. But you wanna make sure that depending on whatever plan you're on that you can afford to run it because realistically, running multiple prompts saying, do this, check your work, consider that on medium could eventually get you to the exact same output that you could have one shot it with extra high.
15:01And an extra twenty minutes of your time isn't worth a 100,000, a million tokens to spend on the exact same outcome. And when it comes to max, heavy, ultra, deluxe, whatever the name is, you should rarely ever be using it because like you would have seen with that one example, I could show you five more where you will get an incremental change between each effort level, but that incremental change doesn't justify the four x, the five x multiple of tokens that you're spending on that task.
15:26So hopefully, this gives you a road map on how to navigate this amorphous thing called effort So you can spend more time on the right task with the right effort level and preserve as many tokens as you possibly can because we will live in a future in the not so distant future where you have to be very frugal of what you spend on what task.
15:44And to make this process easier for you, I've left a guide that you can pick up in the second link down below in the description that has a summary of my mental model around using what model for what task, and I go much deeper, especially if you use Claude code. And as always, if you wanna go infinitely deeper and focus on tactical, realistic use cases of using AI either in your life or your business, you wanna check out the first link down below for my early adopters community.
16:08The rest of you, if this video helped you and gave you clarity, I'd super appreciate a like and comment on the video. It helps the video and the reach of the channel. I'll see you in the next one.
The Hook
The bait, then the rug-pull.
Every AI provider now ships an effort dial — low, medium, high, extra-high, max — and most people treat the highest setting as a shortcut to the smartest possible answer. This breakdown runs the same prompt across 12 effort levels on two different coding tools to show exactly how false that assumption is.
Named ideas worth stealing.
02:07list
The Effort Spectrum
- Low — fast + cheap
- Medium — everyday
- High — default zone
- XHigh — long runs
- Max — specialty
A five-rung ladder of effort levels shared conceptually across providers, from cheapest/fastest to most expensive/slowest.
Steal forDeciding how much reasoning budget to allocate per task type before starting work.
04:00model
Start Intentional (model-first sequencing)
- Sonnet — the workhorse (UI tweaks, file generation)
- Opus — the logic (architecture, debugging, trade-offs)
- Fable 5 — big brain, low dial (complex problems, start on low)
Pick the model family for the task's complexity first, then default every model to low effort and only raise it when the output disappoints.
Steal forStructuring any multi-model workflow so you're not paying frontier-model prices for simple tasks.
06:37concept
Four Ladders, One Dial
- Anthropic — effort (max/xhigh/high default/medium/low)
- OpenAI — reasoning effort (max/xhigh/high/medium default/low/none)
- xAI — reasoning effort (high default/medium/low)
- Google Gemini — thinking level (high/medium default/low/minimal)
Each provider names and defaults its effort dial differently, so a 'high' setting isn't equivalent across Claude, GPT, Grok, and Gemini.
Steal forAvoiding the mistake of assuming the same effort label behaves the same way when switching providers.
15:37model
The Decision Tree
- Know what 'done' looks like? → Low
- Normal daily work? → Default
- Unknown cause or competing needs? → High
- Long, unattended, retries cost more? → XHigh/Max
A branching mental model for choosing effort level per task, with an 'escalate one rung on evidence' rule connecting each branch.
Steal forA reusable checklist for picking effort level on any new model release, without re-learning from scratch.
How they asked for the click.
VERBAL ASK
16:02link
“I've left a guide that you can pick up in the second link down below in the description that has a summary of my mental model around using what model for what task.”
Soft CTA delivered at the very end after the framework recap, reinforced by an on-screen 'Get My Mental [Model]' button overlay; a second, earlier CTA points to the creator's paid 'early adopters' community around the 5:48 mark.
MENTIONED ON CAMERA
FROM THE DESCRIPTION
PRIMARY CTAWhere the creator wants you to go next.
OTHER LINKSAlso linked in the description.
Visual structure at a glance.
