Skip to content
BSWEN
Blog

GPT and Claude Token Usage Burning Fast? How to Optimize and Avoid Hitting Limits

Cowrie
Cowrie
Dev @ Bswen

Problem

I signed up for ChatGPT Plus expecting consistent monthly usage. A few weeks later, I hit my limit. I hadn’t even used it that much.

When I checked Reddit, I found I wasn’t alone. One user said: “5.4 rolled out… basically UNLIMITED token usage for all subscription plans. A couple of weeks go by and it’s time to end the free lunch, they roll back the free credits/resets - instantly everyone flies through their limits.”

Another user complained: “I’m using Plus and it’s burning usage like crazy, like how is this 2x they said?”

Something changed. And it’s burning through my subscription faster than I expected.

What happened?

I thought my token usage would be predictable. Same subscription, same work patterns, same costs.

But I was wrong on three counts:

  1. Newer models consume more tokens - Advanced reasoning models like GPT-5.x and Claude Opus use chain-of-thought internally. One visible task equals multiple hidden reasoning steps. Each step burns tokens.

  2. Providers reduced baseline allocations - Launch promotions offered generous limits. Those limits tightened as the user base grew. One user noted: “The limits reduced and usage is quickly draining.”

  3. Complex tasks multiply costs exponentially - What looks like one request might trigger multiple internal operations.

A Reddit user explained it clearly: “GPT 5.4 consumes usage much faster: 1. Much higher speed of token consumption. 2. Higher token price. Basically it runs on better hardware, faster and more memory. But we must pay for the same week of work with it 2-4x more.”

Another user was scraping by: “Two days till my weekly pro token allowance resets, trying to scrape by on a 5x Anthropic plan.”

Why token usage burns faster

Let me break down the three main factors:

Model Complexity Tax

Advanced reasoning models don’t just answer - they think. And thinking costs tokens.

What you see:     "Fix this bug"
What happens:      Model analyzes code
                    → Model considers options
                    → Model tests solutions internally
                    → Model writes response
                    → Each step = tokens consumed

Faster responses often mean more parallel processing, which means more tokens burned in less time.

Reduced Baseline Allocations

The pattern is consistent across providers:

Launch Phase:     "Unlimited" tokens, generous resets
Growth Phase:     Quietly reduced allocations
Mature Phase:     Stricter limits, weekly instead of monthly resets

One user put it bluntly: “200 is really the new 20.” The perceived value drops as limits tighten.

Prompt Engineering Gaps

I was making my problem worse:

  • Repeating context in every message
  • Not using conversation memory effectively
  • Sending entire codebases when snippets would suffice
  • Starting new chats instead of continuing threads

How I optimized my token usage

After hitting my limit multiple times, I changed my approach:

1. Right-size the model for the task

model_selection.py
# BAD: Using the most powerful model for everything
response = client.chat.completions.create(
    model="gpt-5.4",  # Most expensive for simple tasks
    messages=[
        {"role": "user", "content": "Format this date: 2026-03-16"}
    ]
)


# GOOD: Match model to task complexity
response = client.chat.completions.create(
    model="gpt-4o-mini",  # Cheaper, fast, good enough
    messages=[
        {"role": "user", "content": "Format this date: 2026-03-16"}
    ]
)

Simple tasks (formatting, grammar, basic questions) don’t need the most powerful model. Reserve the expensive models for complex reasoning.

2. Cache and reuse context

context_caching.py
# BAD: New conversation, repeating full context every time
response = client.chat.completions.create(
    model="gpt-5.4",
    messages=[
        {"role": "user", "content": f"""
        Here's my entire codebase: {full_codebase}
        Here's my style guide: {style_guide}
        Here's my requirements: {requirements}
        Fix this function: {function_to_fix}
        """}
    ]
)


# GOOD: Threaded conversation, minimal context
response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[
        {"role": "system", "content": cached_style_guide},  # Cached once
        {"role": "user", "content": f"Fix this function: {function_to_fix}"}
    ]
)

The second approach sends the style guide once as a system message. Subsequent messages don’t need to repeat it.

3. Break complex tasks into stages

Instead of one massive prompt, I split work into focused stages:

Stage 1 (cheap model):  Analyze the problem, identify key files
Stage 2 (cheap model):  Extract relevant code sections
Stage 3 (expensive model): Design the solution
Stage 4 (cheap model):  Implement the changes
Stage 5 (cheap model):  Review and test

This way, I only pay premium token prices for the thinking-heavy stage.

4. Monitor consumption in real-time

I started checking my usage dashboard daily instead of waiting for the “limit reached” message. This helped me:

  • Identify which tasks burn the most tokens
  • Adjust my workflow before hitting limits
  • Understand the real cost of different operations

Model selection guide

Here’s how I choose models now:

Task Type                    → Model Choice
─────────────────────────────────────────────
Formatting, grammar          → Smallest/cheapest
Simple Q&A                   → Smallest/cheapest
Code completion              → Code-specialized or mid-tier
Bug fixing                   → Mid-tier or high-tier
Architecture design          → High-tier
Complex reasoning            → Highest tier
Multi-step analysis          → Highest tier

The key insight: most of my daily work doesn’t need the most powerful model. I was overpaying for simple tasks.

Common mistakes I made

Mistake 1: Using the most powerful model for everything

I thought: “I want the best results, so I’ll use the best model.”

Reality: The “best” model for formatting a date is overkill. I was burning 10x more tokens than necessary for simple tasks.

Mistake 2: Starting new conversations instead of continuing threads

I thought: “Fresh start, clean context.”

Reality: New conversations mean re-sending all context. Continuing a thread reuses previous context, saving tokens.

Mistake 3: Copy-pasting entire files

I thought: “More context is better.”

Reality: Sending a 500-line file when I only need 20 lines wastes tokens on irrelevant data. The model processes everything I send.

Mistake 4: Ignoring usage dashboards

I thought: “I’ll check when I get close to the limit.”

Reality: By the time I checked, I’d already hit it. Now I check daily.

When to consider alternatives

If you’re consistently hitting limits, consider:

  1. API over chat interfaces - More transparent pricing, better cost control
  2. Self-hosted models - No token limits, but requires technical setup
  3. Hybrid approach - Use expensive models only for tasks that need them

One Reddit user shared a smart strategy: “$200 Claude plan for system design/reviews, $20 Codex for implementation.” Match the tool to the task.

What we don’t know

Providers don’t publish:

  • Exact token allocation formulas for each plan
  • Whether they throttle based on usage patterns
  • Real-time token pricing for internal reasoning
  • Changelogs when limits change

This opacity makes optimization harder. I can only work with what I observe.

Summary

In this post, I explained why AI subscription token limits drain faster than expected and how to optimize usage.

The key points:

  • Newer, smarter models cost more tokens per task (2-4x in some cases)
  • Providers reduce allocations after launch promotions end
  • Internal reasoning steps multiply token costs
  • Right-size your model to the task complexity
  • Cache and reuse context instead of repeating it
  • Break complex tasks into stages with appropriate models
  • Monitor usage daily, not just when you hit limits

Token optimization isn’t about using AI less - it’s about using it smarter. Once I understood how tokens actually work, I could make my subscription last the whole month.

Final Words + More Resources

My intention with this article was to help others share my knowledge and experience. If you want to contact me, you can contact by email: Email me

Here are also the most important links from this article along with some further resources that will help you in this scope:

Oh, and if you found these resources useful, don’t forget to support me by starring the repo on GitHub!

Comments

Tags: