Let me tell you about the moment I realized I was wasting money on AI tools. It wasn't the monthly subscription bill that hit me—it was the soul-crushing 'you've hit the limit' message that popped up mid-task. I was trying to debug a simple function in Claude Code, and suddenly, my $500/month AI assistant was telling me to wait. That’s when I decided to dig into the settings, and what I found changed everything. One tiny adjustment—a shift from 'High' to 'Medium' effort—dropped my token burn by 45%. But this isn’t just a cost-saving hack; it’s a revelation about how we interact with AI in the first place.
What makes this particularly fascinating is how deeply we’ve internalized the idea that more is always better. We’ve been conditioned to believe that if an AI tool is thinking harder, it must be working smarter. But here’s the thing: I watched Claude Code complete complex tasks with the same accuracy on 'Medium' effort as it did on 'High.' That’s not just a technical win—it’s a philosophical shift. We’re not paying for intelligence; we’re paying for the illusion of it. And that’s a dangerous mindset to carry into the future of AI development.
Let’s talk about the 'effort' settings themselves. Anthropic’s adaptive reasoning system is a clever compromise, but it’s also a trap. When you see options like 'Max' or 'Xhigh,' your brain screams, 'I need the best possible outcome!' But what if 'Medium' is actually the optimal setting for most of our work? I’ve spent hours watching Claude Code burn through tokens on tasks that required nothing more than a basic search-and-replace. The model wasn’t just overthinking—it was performing a kind of digital self-flagellation, consuming resources like a glutton at a buffet.
This raises a deeper question: Are we designing AI tools for humans, or are we designing humans for AI tools? The way we’re forced to choose between 'High' and 'Medium' effort levels suggests we’ve become dependent on these systems. We’ve built a feedback loop where we assume complexity equals value, even when the evidence shows otherwise. What many people don’t realize is that the 'High' setting is often a crutch for lazy programming. When I tested the same tasks on both settings, the 'Medium' version didn’t just save tokens—it completed the work faster, with no discernible drop in quality. That’s not a minor optimization; it’s a redefinition of what constitutes 'good enough.'
A detail that I find especially interesting is how this mirrors broader trends in productivity software. We’ve all been sold the myth that more features = more efficiency, but the reality is that most of us use only a fraction of what’s available. Claude Code’s 'effort' system is just another example of this. We’re told to maximize every setting, but in practice, we’re drowning in complexity. If you take a step back and think about it, this isn’t just about cost savings—it’s about reclaiming control over our tools instead of letting them control us.
What this really suggests is that we need to start asking harder questions about the AI tools we rely on. Why are we paying for 'Max' effort when 'Medium' gets the job done? Why do we assume that deeper thinking always leads to better outcomes? These aren’t just technical decisions—they’re cultural ones. The way we interact with AI is shaping the future of work, and right now, we’re making choices based on assumptions that might be outdated. I’ve seen developers spend hours tweaking effort levels, chasing token efficiency like it’s a game. But the truth is, we’re not competing with each other—we’re competing with the systems we’ve built. And if we’re not careful, we’ll end up optimizing for the wrong metrics.
So here’s my challenge to you: Next time you fire up an AI tool, ask yourself if you’re using it because you need it—or because you’ve been conditioned to believe that more is always better. The difference between 'High' and 'Medium' effort in Claude Code isn’t just about saving tokens. It’s about redefining what it means to be efficient in the age of AI. And if we’re not willing to question our assumptions, we’ll keep paying for complexity when simplicity is the real innovation.
