← Back to Blog

How I Stopped Losing My Flow Every 2 Hours (and Cut Costs by 90%)

• by Jared Little • AI Learning
How I Stopped Losing My Flow Every 2 Hours (and Cut Costs by 90%)

How I Stopped Losing My Flow Every 2 Hours (and Cut Costs by 90%)

Executive Summary

Hitting Claude usage limits mid-session was killing my flow state and productivity. By switching from Claude.ai to Claude Code and implementing focused session management, I went from hitting limits every 2 hours to maintaining 4+ hour uninterrupted sessions—while cutting costs by 90%. This isn’t about using AI less; it’s about using it smarter through better context management, strategic conversation closure, and workflow optimization. Key insight: treat Claude like a specialized consultant you hire for focused sessions, not a colleague you chat with all day. Full workflow breakdown and session management strategies included below. For complete session tracking methodology, see the Session Management Guide.

I used to lose my flow state every 2 hours when Claude would hit usage limits.

Mid-refactor. Mid-debugging. Right when I was finally understanding the problem.

It wasn’t just annoying—it was destroying my productivity.

Here’s how I fixed it (and accidentally cut my costs by 90% in the process).

The Problem: Flow State Interrupted

Tuesday, 3:47 PM.

I’m deep in a refactor. I’ve got three files open, I’m tracing a bug through the codebase, and I finally understand what’s happening.

I ask Claude to help me implement the fix.

“You’ve reached your usage limit. Please wait 2 hours and 13 minutes.”

My flow state: gone.

The context I’d built up over the last 90 minutes: lost.

The momentum: dead.

This Was Happening Multiple Times Per Session

As a side hustle developer, I work in focused weekend sessions or evening blocks when I can carve out time.

Saturday morning session? Hit the limit by noon.

Sunday afternoon deep dive? Limit hit 2 hours in.

Weeknight coding session after work? You guessed it. Another limit wall just when I’m getting into flow.

I wasn’t managing my budget poorly. I was hitting usage limits because I was working in long, focused sessions—exactly how you’re SUPPOSED to work on complex problems.

The system was punishing me for being productive, and with limited time available for side projects, every interruption hurt even more.

The Investigation: Why Am I Hitting Limits So Fast?

I started tracking what was happening.

What I discovered:

On Claude.ai, I’d have one long conversation thread for an entire project:

  • Start: “Help me build a landing page”
  • 30 messages later: “Now let’s add a contact form”
  • 50 messages later: “Let’s refactor the CSS”
  • 70 messages later: LIMIT HIT

Every message was re-reading the entire conversation history.

Message 1: 500 tokens Message 30: 15,000 tokens Message 50: 40,000 tokens Message 70: 80,000 tokens

The same question at the end of the session cost 160x more than at the beginning.

I was paying exponentially more for each interaction, even though the value was the same.

The First Breakthrough: Understanding Context Bloat

Here’s what I didn’t understand about how Claude works:

Every time you send a message, Claude doesn’t just read your new message. It re-reads the ENTIRE conversation.

Why? To understand context and maintain continuity.

But here’s the problem:

After 2 hours of working on a landing page, I’d ask: “How do I center this div?”

Claude would re-read:

  • The entire initial requirements discussion
  • All the color palette decisions
  • Every iteration of the header design
  • The full debate about mobile responsiveness
  • 15 different code snippets
  • And then answer my CSS question

Most of that context was irrelevant to my current question.

But I was paying for all of it. Every. Single. Time.

The Switch: Claude.ai → Claude Code

A friend mentioned Claude Code—the VS Code extension.

“It’s the same Claude, but integrated into your editor.”

I was skeptical. How would that help with usage limits?

But then I discovered two game-changing features:

1. Better Artifact Management

On Claude.ai, artifacts would scroll away in the conversation. I’d spend 5 minutes scrolling back to find that code snippet from earlier.

In Claude Code:

  • Artifacts show up as actual files in my editor
  • I can save them, version them, organize them
  • I can reference them later without including them in the conversation

This meant I could work on a feature, save the artifact, start a NEW conversation for the next feature, and reference the old work without bloating the new conversation.

2. File Context Control

In Claude.ai, I’d paste entire files into the conversation to give context.

In Claude Code:

  • Claude can read files directly from my project
  • I control exactly which files it sees
  • No need to paste huge code blocks into the chat

Smaller conversations = lower token usage = longer before hitting limits.

The Strategy: Smart Session Management

Once I switched to Claude Code, I developed a new workflow:

Rule 1: One Conversation Per Feature

Old way (Claude.ai):

One mega-conversation:
- Build landing page (30 messages)
- Add contact form (20 messages)
- Refactor CSS (15 messages)
- Add mobile menu (10 messages)
Total: 75 messages, 150,000+ tokens

New way (Claude Code):

Session 1: Landing page structure → Close when done
Session 2: Contact form → Close when done
Session 3: CSS refactor → Close when done
Session 4: Mobile menu → Close when done

Total tokens: Same work, 60% fewer tokens

Rule 2: Save Artifacts, Start Fresh

After completing a feature:

  1. Save all artifacts as actual files
  2. Close the conversation
  3. Start a new conversation for the next feature
  4. Reference old files only when needed

Before: Every new question carried the weight of all previous work After: Each conversation stayed lean and focused

Rule 3: Use /compact Strategically

Claude Code has a /compact command that:

  • Removes old context
  • Keeps recent work
  • Resets token usage

I use it after completing discrete tasks:

✅ Feature done → /compact → Next task

Not:

❌ Task 1 → Task 2 → Task 3 → /compact

Rule 4: Be Specific About File Context

Token-heavy approach:

"The app isn't working, can you check everything?"
→ Claude reads 15 files to diagnose

Token-efficient approach:

"The user registration in auth/register.ts is failing on line 42. The error is 'undefined email'. Can you check the form submission logic?"
→ Claude reads 1 specific file

The Results: Flow State Restored

Before (Claude.ai):

  • Hit limits every 2 hours
  • Lost flow state 3-4 times per day
  • Spent time waiting for resets
  • Frustrating, momentum-killing experience
  • Cost: ~$50/week

After (Claude Code + Strategy):

  • 4+ hour uninterrupted sessions
  • Flow state maintained all day
  • No more “waiting for reset” breaks
  • Actually MORE productive because I’m batching focused work
  • Cost: ~$5/week

The cost savings was a happy accident. The real win was getting my flow state back.

Quick Wins You Can Implement Today

You don’t need to switch tools or overhaul your entire workflow. Start with these:

Win 1: Start Fresh Sessions More Often (5 minutes)

Instead of: One conversation all day long

Try: Close your conversation after completing each major task. Start fresh for the next one.

Savings: 30-40% token reduction immediately

Win 2: Be Surgically Specific (2 minutes per question)

Instead of: “The login isn’t working, can you check?”

Try: “The login form in src/auth/Login.tsx submits but returns undefined. The POST request to /api/login shows a 200 status but empty response body. Can you check the API route?”

Savings: 50-70% token reduction per interaction

Win 3: Don’t Paste Entire Files (1 minute)

Instead of: Copying 200 lines of code into the chat

Try: “Check the handleSubmit function in src/components/ContactForm.tsx, specifically lines 45-67”

Savings: Massive reduction in context bloat

Win 4: Close Conversations When You’re Done (10 seconds)

Instead of: Keeping the same conversation open for days

Try: Finish a feature? Close the conversation. Start fresh tomorrow.

Savings: 40-60% token reduction

The Mindset Shift

The key insight that changed everything:

Claude isn’t a human colleague you keep chatting with all day.

Claude is a specialized expert you bring in for focused consulting sessions.

Would you pay a $300/hour consultant to sit with you all day while you context-switch between unrelated tasks?

No. You’d:

  1. Define a specific problem
  2. Have a focused consultation
  3. Implement the solution
  4. End the session
  5. Start a new session for the next problem

Do the same with Claude:

  1. Define ONE goal
  2. Work through it
  3. Complete the task
  4. Close the conversation
  5. Start fresh for the next goal

The Claude Code Advantages

If you’re still on Claude.ai, here’s why I recommend switching to Claude Code:

1. Artifact Tracking

  • Artifacts become real files
  • Easy to find, version, and reuse
  • No scrolling through chat history

2. File Context Control

  • Claude reads your actual project files
  • You control what it sees
  • No copy/pasting code blocks

3. Workflow Integration

  • Works in your editor
  • See code and chat side-by-side
  • Faster iteration

4. Session Management

  • Easy to close/start conversations
  • /compact command built-in
  • Better context control

5. Productivity

  • No context switching between browser and editor
  • Faster workflow
  • Better focus

My Current Workflow (Weekend/Evening Sessions)

Here’s exactly how I work now as a side hustle developer:

Saturday Morning - Session 1: Feature Planning (10:00 AM)

  • Open Claude Code in VS Code
  • “Let’s plan the architecture for [feature]”
  • Get the plan, save it as a file
  • Close conversation

Session 2: Implementation (10:30 AM)

  • Open new conversation
  • “Implement [first component] from the plan”
  • Code, test, iterate
  • /compact after each sub-feature
  • Close when feature is done

Session 3: Next Feature (12:00 PM)

  • Fresh conversation
  • Reference previous work only when needed
  • Focused, lean context
  • /compact as needed

Still Going Strong (2:00 PM)

  • No usage limits hit
  • Flow state maintained
  • Actually shipping features

Final Session (4:00 PM)

  • Documentation and cleanup
  • Still have budget left
  • Can keep working if needed

End of weekend session:

  • 4-6 hours of productive work
  • Multiple features shipped
  • $1-2 spent instead of $15-20
  • No flow state interruptions
  • Maximized my limited side project time

The Real Metrics

Let me show you the actual numbers from my recent sessions (tracked using my Session Management Guide):

Weekend Session 1 (Saturday)

  • Duration: 5 hours
  • Sessions: 4 focused sessions
  • Features shipped: User authentication + Dashboard UI
  • Tokens used: 45,000
  • Cost: $0.90
  • Interruptions: 0

Evening Sessions (Mon-Fri)

  • Duration: 1-2 hours each
  • Sessions: 1-2 focused sessions per evening
  • Features shipped: Blog system improvements, auto-publishing, bug fixes
  • Tokens used: ~8,000 per session
  • Cost: $0.15-$0.30 per evening
  • Interruptions: 0

Weekend Session 2 (Sunday)

  • Duration: 6 hours
  • Sessions: 5 focused sessions
  • Features shipped: Theme toggle + guides section + documentation
  • Tokens used: 52,000
  • Cost: $1.05
  • Interruptions: 0

Weekly Total:

  • Cost: $3-5 (vs $50+ before)
  • Features shipped: 10+ production features
  • Flow state interruptions: 0 (vs 15-20 before)
  • Productivity: ↑ 3x
  • Time efficiency: Critical when you only have weekends and evenings

The cost savings is great. But the real win is uninterrupted flow state in my limited side project time.

Your Action Plan

This Week:

  1. If you’re on Claude.ai: Try Claude Code

    • Install the VS Code extension
    • Work on one feature to test it
    • Notice how artifact management feels

  2. Start closing conversations:

    • Finish a task? Close it.
    • New task? New conversation.
    • Track how much longer you can work

  3. Be more specific:

    • Name the file
    • Cite the line numbers
    • Describe the exact problem

Next Week:

  1. Track your metrics:

    • How long between limit hits?
    • How many features shipped?
    • How’s your flow state?

  2. Refine your workflow:

    • When do you /compact?
    • When do you start fresh?
    • What’s your session length?

  3. Build your system:

    • Document what works
    • Iterate on what doesn’t
    • Share with others

The Bottom Line

I didn’t optimize my workflow to save money.

I optimized to get my flow state back.

The cost savings was a bonus.

If you’re hitting usage limits and losing momentum, you’re not managing your budget poorly—you’re being productive in a way the system wasn’t designed for.

The solution isn’t to use Claude less. It’s to use it smarter.

Switch to Claude Code. Start fresh sessions. Be specific about context. Use /compact.

Your flow state (and your wallet) will thank you.

Tools Mentioned:

Coming Next: Part 2 of this series will be a deep-dive case study with all the metrics, complete workflow breakdown, and advanced optimization techniques. Stay tuned.

Questions? Drop a comment or reach out. I’m always optimizing this workflow and happy to share what I learn.

Your flow state matters more than your token count.