LLM Thinking Levels in Practice: How to Choose Between Low, High, and Max
This hands-on comparison of Low, High, and Max thinking levels uses one front-end task, an SVG expression system, to show how each level affects design depth, code volume, and bug rate. It also explains why total delivery cost, not response speed alone, should guide the choice, and offers practical guidance on when to use each level.
1. Background: What Thinking Levels Are
Many mainstream AI coding tools offer several thinking modes. A typical setup has four levels: thinking off, low, high, and max. Each level trades reasoning-stage token budget against final output quality.
- More thinking tokens give the model more room to work through solution designs, correct its own mistakes, and refine details.
- Fewer thinking tokens make responses faster and cheaper, but solutions are more likely to take shape too quickly and without enough scrutiny.
Understanding how each level behaves is the first step toward using these models well. The following sections compare the levels on one practical task.
2. Test Task Design
The test task was a front-end project of medium complexity. The requirements were:
Build a minimalist expression system page based on SVG animation. Start with the basic emotions of anger, disgust, fear, sadness, surprise, happiness, and calm, and expand the set to 12 expressions. Each expression must have dynamic features, such as blinking and mouth corner changes, so it does not look stiff. Also provide an automatic drifting switch mechanism that appears random in rhythm.
The task has no single correct answer. It is creative and involves state machine design and animation details, which makes it useful for comparing the design depth of different thinking levels.
3. Comparing the Three Levels
3.1 Low: Draft-style output, fast but error-prone
Low level reasoning is very short. The model often finishes thinking within a few lines and starts writing right away. In this test, the final code was only about eight lines of core logic, which suggests the model wrote whatever came to mind first.
The problems were:
- The initial plan lacked careful reasoning. For example, the state machine for switching expressions was oversimplified.
- When the first approach failed, many rounds of editing and verification were needed to fix it. Time saved in the early stage was paid back later as repair cost.
- The output looked rushed, and details were under-polished.
Low level still has value. Its initial creative directions are sometimes more original. It works well as a draft generator, where a person selects the best ideas and then iterates.
3.2 High: The sweet spot with the best value
High level reasoning adapts well to the task:
- Simple problems get short thinking time, so no tokens are wasted.
- Complex problems get engineering-style analysis. For example, the model first designed a parameterized structure for the expressions, then planned the easing curves for the switch animations.
In this test, High level produced about 600 lines of code. Its execution time was close to Max level, and it needed only a few small fixes for minor bugs. For most everyday coding tasks, High is the recommended default.
3.3 Max: Deep reasoning with diminishing returns
Max level reasoning was laborious. The model spent a long time deliberating on the solution design and then on implementation details. It sometimes discarded parts of its plan and started over before writing code. In this test, Max level produced about 900 lines of code.
The costs were:
- Thinking token usage rose significantly, and total time increased.
- Bugs still appeared in this test, and the quality was not clearly better than High level.
- For creative tasks, excessive reasoning can make the solution more conservative and similar to common patterns.
4. Cost Structure: First Writing Versus Verification and Fixes
The total cost of a coding task has two parts:
- First-pass writing cost, which increases with the thinking level. Higher levels mean longer thinking.
- Verification and fix cost, which decreases as the initial solution improves. A rushed solution needs more fixes.
The key finding is that Low level does not necessarily have the lowest total cost. In this test, the initial approach failed under Low level, which greatly increased the number of repair and verification rounds. As a result, its final time and cost were higher than those of High level. When choosing a thinking level, evaluate the total cost of delivery, not just how fast a single response arrives.
5. Practical Recommendations
- Use High by default. It covers most coding, refactoring, and debugging tasks and offers the best balance of quality and cost.
- Use Low in two situations. The first is simple tasks where response speed matters most. The second is early creative exploration. Use Low to generate several directions quickly, then select and iterate on them manually.
- Use Max sparingly. Enable it only for high-value work such as architecture-level design or complex algorithm derivation, and plan your token budget accordingly.
- Keep humans involved in creative work. Long reasoning tends to converge on safe solutions. Standout creative results usually come from several rounds of small experiments rather than one deep reasoning pass.
6. Conclusion
A higher thinking level is not always better. Choosing a level is an engineering trade-off. Treat level selection as part of task routing, and match the level to task complexity, creative needs, and budget. This is how model capability turns into delivery efficiency. Developers should run a similar comparison on their own typical tasks and set up a team guideline for choosing thinking levels.
