Skip to content
BSWEN
Blog

How to Optimize AI Coding Model Usage and Avoid Hitting Rate Limits

Cowrie
Cowrie
Dev @ Bswen

I burned through my $200 ChatGPT Pro subscription in less than two weeks. Then I hit my Claude limit too.

Turns out I was doing everything wrong. After hitting the wall hard enough to reconsider my entire workflow, I found a pattern that’s kept me productive without constantly bumping into usage limits.

The Problem

I was running three AI coding sessions simultaneously per project: one for general coding, one for security and performance review, and one for documentation. Each session was using top-tier models (Opus, GPT-4.5) for everything from simple typo fixes to complex architectural decisions.

That approach drained my allocation fast.

Looking at my usage patterns, I noticed several problems:

  • Every session loaded my entire AGENTS.MD context file
  • I had “fast mode” enabled, which doubled my credit consumption
  • Subagents were spawning additional model calls without me realizing
  • I used premium models for tasks that didn’t need them

The Tiered Model Strategy

The solution was matching model capability to task complexity. I switched to a three-phase approach:

+------------------+-------------------+------------------+
|      Phase       |    Model Tier     |   Token Cost     |
+------------------+-------------------+------------------+
| Plan & Architect | Opus 4.6, GPT-4.5  | High             |
| Implement        | Haiku, GPT-4-mini  | Low (3x savings) |
| Verify & Review  | Opus 4.6, GPT-4.5  | High             |
+------------------+-------------------+------------------+

Planning Phase: I start with high-end models for architectural decisions and complex problem-solving. This is where I need the best reasoning capability. I do this in the regular web interface before switching to my IDE.

Implementation Phase: Once I have a clear plan, I switch to cost-effective models for the actual coding. Haiku and GPT-4-mini handle 90% of implementation tasks perfectly fine. They’re faster and consume a fraction of the tokens.

Verification Phase: I return to premium models for code review, security checks, and final testing. This catches issues that cheaper models might miss.

Context Bloat Was Killing Me

My AGENTS.MD file had grown to over 2000 lines. Every new session loaded this entire context, burning tokens before I even started working.

I trimmed it down to the essentials:

  • Core project architecture
  • Critical coding patterns
  • Essential tool references

Everything else moved to task-specific documentation that I reference only when needed.

The “Fast Mode” Trap

I didn’t realize “fast mode” in general settings was doubling my credit usage. It seemed convenient—faster responses!—but the cost was unsustainable.

Turning it off cut my consumption in half. The slightly slower responses are worth the extended subscription life.

Subagents Multiply Costs

Subagents are convenient but expensive. Each one spawns additional API calls. When I had three sessions running, each with potential subagents, my token consumption multiplied.

Now I limit myself to one or two concurrent sessions maximum. I complete one task before starting another.

What Actually Works

Here’s my current workflow:

  1. Plan in the web interface with GPT-4.5 (no IDE overhead)
  2. Switch to IDE with GPT-4-mini for implementation
  3. Review in web interface with GPT-4.5 for verification

This approach has kept me under my limits for the entire billing cycle.

When You Still Need Premium Models

Some tasks genuinely require the best models:

  • Architectural decisions affecting the entire codebase
  • Security-critical code review
  • Complex debugging across multiple systems
  • Novel problem-solving without clear precedent

For everything else, the tiered approach works.

Common Mistakes I Made

  • Using Opus for typo fixes and formatting
  • Running multiple sessions “just in case”
  • Ignoring context file size
  • Leaving fast mode enabled by default
  • Not leveraging cheaper models that are 90% as capable

The lesson: premium models for premium problems. Routine work doesn’t require routine premium spending.

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: