DEV Community: Jamie

I ran a 14-day build sprint and found one pattern behind both high AI bills and doomscrolling

Jamie — Tue, 10 Mar 2026 19:03:54 +0000

For two weeks I tracked two numbers every day:

AI spend per coding session
Unplanned feed time

I expected these to be separate problems.
They weren’t.

On high-scroll days, my prompts were sloppier, context was messier, and I retried more.
Same code outcome, way more token burn.

What changed

1) I started checking session cost while coding (not at month-end)

When I waited for the monthly bill, every expensive session felt random.
Real-time visibility changed behavior immediately.

I built TokenBar for this: a $5 Mac menu bar tracker that shows token/cost usage live while I work.
https://tokenbar.site

2) I stopped “blocking apps” and blocked feeds instead

Deleting apps never stuck for me.
I still needed DMs, groups, and search.
The loop only broke when the algorithmic feed surface disappeared.

I built Monk Mode for that: a $15 Mac app that blocks feed-level distractions while keeping useful app functions.
https://mac.monk-mode.lifestyle

3) I added one tiny ritual

Before starting an AI-heavy task:

write 3 lines of scope
choose model tier intentionally
set a hard stop for review/retries

This cut panic reruns and expensive “just one more pass” loops.

14-day result

less context thrash
fewer retries
steadier focus blocks
lower AI spend volatility

The biggest lesson: attention leaks become budget leaks when you code with AI all day.

If you’re a solo builder, treat focus and token spend as one system, not two separate habits.

I stopped treating AI spend and doomscrolling as separate problems — 7 fixes that shipped real work

Jamie — Tue, 10 Mar 2026 17:33:52 +0000

Last month I kept asking the same question: why am I "busy" all day but shipping so little?

Two things were happening at once:

my AI coding costs kept jumping week to week
my attention kept getting nuked by feeds between coding blocks

I treated them as two separate problems for way too long.
They’re the same problem: feedback loops.

When you can't see cost in real time, you overspend.
When you keep open algorithmic feeds, you context-switch.
Both create noisy work and expensive retries.

Here are the 7 fixes that actually worked for me.

1) Add a live cost signal while you code

I now keep token/cost visibility in front of me during sessions.
Not end-of-month billing. Real-time.

That one change killed the "one more retry" spiral.

2) Route by task, not by ego

I used to default to expensive models for everything.
Now I use a simple rule:

heavy reasoning: premium model
boilerplate/refactors/docs: cheaper model

Most work does not need top-tier reasoning.

3) Scope before every run (60 seconds)

Before hitting enter, I ask:

what exact output do I need?
what files are actually relevant?
what's the smallest acceptable pass?

This alone reduced wasteful reruns a lot.

4) Block feeds, not whole apps

Deleting apps never lasted.
Blocking just the feed/explore surfaces did.

I can still use DMs, search, and direct messages without infinite scroll.

5) Timebox experiments

Open-ended AI sessions are where costs explode.
I cap experiments to fixed windows, then either commit or kill.

6) Do a daily 5-minute spend review

I track:

biggest expensive session
why it blew up
one rule to prevent repeat

Tiny review, big compounding gains.

7) Protect deep-work blocks like meetings

No feeds, no notifications, one coding objective.
Focused blocks produced better prompts, fewer retries, and lower spend.

The stack I ended up using

TokenBar ($5): menu bar visibility for token/cost usage while coding → https://tokenbar.site
Monk Mode ($15): feed-level blocking on Mac so work blocks stay clean → https://mac.monk-mode.lifestyle

Both came from solving my own workflow mess as a solo builder.

If your AI bill feels random and your focus feels fragmented, try treating them as one system problem for a week.

You'll probably ship more and spend less.

I stopped losing money to AI coding and doomscrolling — 8 rules that finally worked

Jamie — Tue, 10 Mar 2026 16:04:08 +0000

Two months ago I had a dumb pattern:

I’d spend all day “building fast” with AI tools
At night I’d wonder why nothing meaningful shipped
Then the monthly bill arrived and made it worse

I kept treating this like two separate problems:
1) AI token costs were too high
2) my focus was trash

Turns out they were the same problem.

When attention is fragmented, prompts get worse, retries go up, context windows bloat, and every “quick run” gets expensive.

Here are the 8 rules that finally fixed it for me.

1) Track cost while you work, not at the end of the month

Monthly totals are too late. Real-time feedback changes behavior in the moment.

I built TokenBar for this exact reason: a $5 Mac menu bar app that shows live token and cost usage while coding.
https://tokenbar.site

2) Don’t run heavyweight models by default

Most work is boring: renames, formatting, cleanup, small refactors.
Save premium models for genuinely hard reasoning.

My rough split now:

cheap/fast model for ~70-80% of tasks
stronger model only for architecture/debug dead ends

3) Add a 2-minute scope pass before every big run

Before pressing Enter, I ask:

What exactly is the outcome?
Which files are truly relevant?
What should the model ignore?

That tiny step alone cut a lot of accidental token burn.

4) Block algorithmic feeds, not the entire internet

Deleting apps never lasted for me.
What worked was removing the feed loops while keeping useful parts (DMs, direct messages, specific pages).

I built Monk Mode for this: a $15 Mac app that blocks feed-level distractions instead of nuking whole apps.
https://mac.monk-mode.lifestyle

5) Protect “first hour focus” like revenue depends on it

Because it does.
If my first hour is clean, prompts are clearer and I need fewer retries all day.
If I start with feed-scrolling, quality drops and AI spend climbs.

6) Batch review requests

Random tiny review calls all day create overhead.
I now batch related changes into cleaner review chunks.
Quality went up, cost went down.

7) End each day with a 5-line postmortem

I log:

what shipped
what burned tokens unnecessarily
what distracted me
one thing to tighten tomorrow

This keeps me from repeating the same expensive mistakes.

8) Optimize for shipped outcomes, not AI activity

Lots of AI output can feel productive while producing zero business value.
My north star now is simple: shipped features + user feedback + spend discipline.

The big lesson: focus and cost are coupled.
If attention is chaotic, token spend gets chaotic.

Once I treated attention like a budget and token usage like a live metric, both improved fast.

If you’re a solo dev building with AI every day, this combo matters way more than another tool-switch debate.

What changed your AI bill the most: better model routing or better focus habits?

I stopped treating productivity like motivation — 9 rules that cut my AI costs and doomscrolling

Jamie — Tue, 10 Mar 2026 14:34:53 +0000

I used to think I had an AI tooling problem.

Turns out I had an attention problem.

My weeks looked like this:

Ship fast with Claude/Cursor/Codex for 45 minutes
"Quick check" social feeds for 20 minutes
Come back, lose context, rerun prompts, waste tokens
Repeat until I felt busy but not done

Here are the 9 rules that finally worked.

1) Track token spend like calories

If you don’t see it, you don’t control it.

I started using TokenBar (https://tokenbar.site) in my Mac menu bar so I can see token usage + estimated cost in real time while coding.

Instantly killed the “one more expensive run” habit.

2) Don’t trust motivation, design constraints

Motivation is random. Friction is reliable.

I block high-dopamine feeds during build windows with Monk Mode (https://mac.monk-mode.lifestyle) so I can’t impulse-switch into scroll mode.

3) Start every session with a cost cap

Before opening the editor, I set a rough ceiling:

cheap tasks: tiny cap
architecture/refactor: bigger cap

This changes prompt quality immediately.

4) Write smaller asks, get cheaper outputs

Big vague prompts = big expensive meandering responses.

Tiny scoped prompts + checkpoints = less drift + less rerun cost.

5) Treat context switches as hidden invoices

Every feed check adds a “rebuild context tax.”
You pay it in time and tokens.

6) Separate explore mode from execute mode

Explore: brainstorm, compare, learn.
Execute: one objective, no feed access, ship.

Mixing both modes created most of my waste.

7) Review usage daily, not monthly

Monthly review is too late.

Daily 2-minute check catches bad loops while they’re still small.

8) Assume your brain will negotiate with you

“I’ll just check for 2 mins” is usually fake.
Make the bad behavior harder than the good behavior.

9) Optimize for shipped output, not prompt count

More prompts can mean less progress.
Track shipped features/tasks, not just activity.

My practical setup now

TokenBar always visible for spend awareness
Monk Mode during coding blocks
Predefined cost caps per session type
Smaller prompts + checkpoint rhythm

Result: lower AI cost, fewer context resets, more shipped work.

If you’re burning money on AI tools, there’s a good chance your biggest leak is attention — not model choice.

I Was Burning Money and Time on AI Coding — 7 Changes That Fixed Both

Jamie — Tue, 10 Mar 2026 13:05:05 +0000

I Was Burning Money and Time on AI Coding — 7 Changes That Fixed Both

A few months ago, my workflow looked productive from the outside:

Cursor open
Claude/Codex running
dozens of “smart” prompts
zero shortage of confidence

But behind the scenes, I was paying for noise.

My token costs were creeping up, my focus was getting wrecked by feed-checking every 10 minutes, and I was finishing fewer real tasks.

So I changed my system. Here are the 7 things that actually worked.

1) Track token usage in real time (not at end of month)

The biggest mistake: I only looked at cost after damage was done.

When I started tracking usage live in my menu bar, I stopped asking lazy, bloated prompts and started batching requests with intent.

That single visibility shift changed behavior immediately.

2) Stop “just one more prompt” loops

I used to keep poking the model for tiny rewrites.
That’s where cost leaks happen.

Now I write one structured prompt with:

objective
constraints
output format
acceptance criteria

Fewer turns, better output, lower bill.

3) Separate build mode from browse mode

Context switching was killing me more than bad prompts.

When I’m coding, I don’t need feeds.
I need one editor, one terminal, one objective.

I started blocking social feeds at the feed level on my Mac during deep work windows. Not entire websites—just the infinite scroll traps.

My sessions got longer, cleaner, and less mentally fragmented.

4) Put a hard cap on daily AI spend

No cap = no urgency.

Set a fixed daily budget. If I hit it, I switch to:

local debugging
docs cleanup
tests/refactors

That forces me to use model calls where they create leverage, not comfort.

5) Use AI for high-leverage chunks, not every keystroke

I now reserve model usage for:

architecture drafts
gnarly bug hunts
test generation
review passes before merge

I do not waste paid tokens on trivial stuff I can do faster myself.

6) Use friction as a feature for distractions

I used to think blocking apps was “too extreme.”
Reality: friction works.

When opening a feed requires extra steps, impulse opens drop hard.
That reclaimed attention goes directly into shipping.

7) Review cost + focus weekly, together

Most people treat these as separate problems:

“I spend too much on AI tools”
“I can’t focus long enough to finish work”

They’re connected.
When attention is scattered, prompts get worse, sessions get longer, and cost rises.

Every week I review both in one checklist:

Which tasks were worth model spend?
Where did token spikes happen?
When did distraction break my flow?

That combo made my workflow tighter every week.

What I use now

Two tiny utilities changed the game for me:

TokenBar — live token/cost tracking in the Mac menu bar (helps me make better prompt decisions in the moment)
Monk Mode — feed-level blocking on Mac (helps me protect focus while coding)

Neither is complicated. Both remove invisible leaks.

If you’re feeling “busy but not shipping,” start by fixing visibility and focus first.
The output usually follows.

7 tiny habits that cut my AI coding bill and doomscrolling in the same week

Jamie — Tue, 10 Mar 2026 11:34:01 +0000

Last month I had two annoying problems:

My AI coding costs were unpredictable.
My focus was wrecked by “quick checks” that turned into feed spirals.

I didn’t fix this with motivation. I fixed it with small constraints.

Here are 7 habits that actually worked.

1) Start every coding block with a spend cap

Before opening Claude/Cursor/Codex, I set a max budget for that block.

Deep feature block: higher cap
Bugfix block: lower cap

When the cap is visible, prompt quality goes up because I stop wandering.

2) Track cost in real time, not end-of-month panic

I started using TokenBar (menu bar app) to watch token/cost usage while I work.

Seeing cost update live changed my behavior immediately:

fewer retry loops
less “just one more big context dump”
faster decision to stop and re-scope

(If you’re curious: tokenbar.site)

3) Run a 2-minute planning pass before generation

My rule: no generation until I can explain the task in 5 bullets.

This tiny pause avoids the expensive cycle:
confused prompt → messy output → long cleanup.

4) Block feeds during coding windows

My biggest hidden cost wasn’t tokens. It was context switching.

I now block distracting feeds during focused windows with Monk Mode.
It blocks at the feed level so I don’t accidentally fall into infinite scroll.

Result: I return to code with the same mental thread.

(If relevant to your workflow: mac.monk-mode.lifestyle)

5) Timebox experiments

When I test a new prompt strategy or agent workflow, I cap it at 20 minutes.
If it’s not clearly better, I kill it.

This protects both money and momentum.

6) Separate “explore mode” from “ship mode”

Exploring tools is valuable. But mixing it with shipping is expensive.

Now I split sessions:

Explore mode: try weird ideas
Ship mode: no detours, no feed access, tight prompts

7) End the day with a 3-line review

I log:

what consumed the most tokens
what triggered distraction
what to change tomorrow

This takes 2 minutes and compounds hard.

What changed in one week

Lower AI spend volatility
Fewer prompt retries
Longer uninterrupted coding streaks
More finished work per day

Not because I became more disciplined.
Because I made the default path cheaper and less distracting.

If you’re currently feeling “busy but not shipping,” start with habits #2 and #4 first. They gave me the fastest visible win.

I stopped guessing my AI costs and my focus — this 20-minute daily system fixed both

Jamie — Tue, 10 Mar 2026 10:04:11 +0000

Last month I kept saying two things:

“I’m working all day.”
“Why is my AI bill still absurd?”

Both were true. And both were the same problem.

I wasn’t just spending too many tokens — I was spending them while distracted.

When I doomscrolled for 5 minutes between prompts, I came back with worse context, lazier instructions, and way more retries.

That pattern quietly doubled my costs.

So I built a simple 20-minute daily system that fixed both money leak and attention leak.

The 20-minute system

1) Morning cost checkpoint (5 min)

Before opening code, I check what yesterday’s sessions actually cost.

I use TokenBar (a $5 Mac menu bar app I built: https://tokenbar.site) so I can see cost in real time while working.

The key is not monthly totals — it’s session-level feedback.

2) Task-to-model plan (3 min)

I write three buckets:

Cheap model tasks (cleanup, small edits, tests)
Mid model tasks (feature implementation)
Heavy model tasks (architecture / hard debugging)

Without this step, everything drifts to the expensive model.

3) Feed-off deep work blocks (10 min setup)

I run two 90-minute blocks where algorithmic feeds are blocked but useful app parts still work.

I use Monk Mode (my $15 Mac app: https://mac.monk-mode.lifestyle) for feed-level blocking.

Why feed-level? Because full app blocking failed for me. I’d disable the blocker. Feed-level blocking keeps messages and utility, removes the trap.

4) End-of-day quick review (2 min)

I log:

total AI spend today
number of retries I did
focused hours

After a week, patterns are obvious.

What changed in 14 days

AI spend dropped ~38%
“retry loops” dropped hard
finished work increased because context stayed cleaner

Big lesson: focus quality directly affects token efficiency.

Most AI cost advice is pricing hacks.
Real win is behavior + feedback loops.

If you’re building with Claude/Cursor/Codex all day, try this for one week:

live cost visibility
model routing by task
feed-level blocking during build blocks

You’ll probably ship more and spend less at the same time.

What’s your current leak: model selection, context bloat, or distraction?

I fixed my AI coding burn rate by treating attention like a budget (not motivation)

Jamie — Tue, 10 Mar 2026 08:34:13 +0000

For a while I thought I had two separate problems:

My AI coding costs were climbing every week.
My focus was trash because of feed-driven distractions.

Turns out they were the same problem wearing different clothes.

When I was distracted, I prompted worse.
Worse prompts = more retries.
More retries = bigger token burn.

What changed

I stopped treating focus as a motivation issue and started treating it like a budget system.

Every work block now has two numbers:

Deep work minutes
AI spend for that block

That single shift made me notice patterns fast:

My most expensive sessions were not complex architecture work.
They were scattered sessions with constant context switching.
“Quick checks” and “one more retry” were quietly eating most of the bill.

The 5 rules that dropped my spend

1) Cap each coding block

I set a rough token/cost ceiling before I start.
If I hit it, I stop and re-scope instead of brute-forcing.

2) Route by task, not ego

Expensive models only for truly hard reasoning.
Most implementation, cleanup, and scaffolding work goes to cheaper models.

3) Short context > giant context

I stopped dumping entire files and logs into every prompt.
Prompt quality beat prompt length almost every time.

4) Kill feed triggers during build windows

Not full app blocking—just the algorithmic feed surfaces.
I can still use messages/search, but I remove infinite-scroll traps.

5) Review sessions nightly

10-minute review: where spend spiked, what caused retries, what to improve tomorrow.

What I built for this workflow

I ended up building two tiny Mac tools around these exact pain points:

TokenBar — a $5 Mac menu bar tracker for live AI token/cost awareness: https://tokenbar.site
Monk Mode — a $15 Mac app that blocks algorithmic feeds while keeping useful app functionality: https://mac.monk-mode.lifestyle

I made them because I wanted systems, not willpower hacks.

Real takeaway

If your AI bill feels random, check your attention system.
If your focus feels random, check your feedback loops.

For me, cost control and focus control ended up being the same operating system.

If you’re building with AI every day, what’s your biggest leak right now: model choice, context bloat, or distraction loops?

I thought my AI bill problem and doomscrolling problem were separate. They weren’t.

Jamie — Tue, 10 Mar 2026 07:04:02 +0000

For a while I treated these as two different issues:

1) "Why is my AI coding spend climbing every week?"
2) "Why do I keep ending days feeling busy but not finished?"

Then I tracked both for two weeks.

What I found was brutal:

On focused days, my AI spend was lower and output was higher.
On distracted days, I rewrote prompts 3-4 times, context ballooned, and costs spiked.

I wasn’t just losing time to feeds.
I was paying for it in tokens too.

What changed for me

1) I started watching token cost in real time

I built a tiny menu bar tracker so I could see spend while coding instead of after the damage was done.
That became TokenBar (https://tokenbar.site) — one-time $5.

The immediate effect: I stopped using expensive models by default for low-stakes tasks.

2) I stopped trying to "quit apps" and removed the feed layer instead

Deleting apps never lasted. Blocking entire websites broke useful workflows.
I needed messages and communities, just not the infinite scroll trap.

So I built Monk Mode (https://mac.monk-mode.lifestyle) — feed-level blocking on Mac, one-time $15.

The immediate effect: fewer context switches, cleaner prompts, less panic-retry behavior.

The practical system I use now

Start day with one shipping target
Keep a live cost signal visible
Run cheap model first, escalate only when needed
Block feeds during build windows
Review token-heavy sessions at the end of day

Nothing fancy.
Just enough friction removed to stay intentional.

If you're building with AI right now

Don’t only optimize prompts.
Optimize your attention loop.

Because distracted development is expensive development.

And once you see both metrics together (focus + spend), you can’t unsee it.

I stopped leaking money to AI tokens and social feeds — 7 rules that actually worked

Jamie — Tue, 10 Mar 2026 05:34:30 +0000

I had a weird pattern for months:

I’d spend all day “building”
My AI bill kept climbing
My shipped output was embarrassing

The painful part: I wasn’t lazy. I was just bleeding attention and tokens at the same time.

So I made a simple system around two tools I built for myself:

TokenBar ($5): a Mac menu bar tracker for real-time token/cost visibility while using Claude, Cursor, Codex, etc.
Monk Mode ($15): a Mac distraction blocker that kills infinite feeds at the feed level.

Here are the 7 rules that finally made my days profitable again.

1) Never start a coding session without a spend ceiling

Before touching code, I pick a max token budget for the session.

Example:

Bugfix block: $2
Feature block: $6
Refactor block: $10

No ceiling = guaranteed overrun.

2) Watch cost in real time, not at month-end

Monthly billing pages are autopsies, not steering wheels.

I keep a live cost counter visible while I work. The moment a thread gets expensive, I compress context or restart cleaner.

3) Split “explore” and “execute” prompts

Most waste came from mixing brainstorming and production in the same long thread.

Now I do:

Explore thread (cheap, rough, short-lived)
Execute thread (focused, test-first, minimal context)

Token burn dropped immediately.

4) Block feeds during deep work (yes, aggressively)

I used to tell myself I’d check socials for “2 minutes.”
That usually became 20.

So I removed the negotiation entirely: if it’s a build block, feeds are blocked.

5) Run 90-minute build sprints with a hard shutdown

No endless marathons.

Structure:

90 min build
15 min review (cost + output)
decide: continue, switch task, or stop

This saved me from burning $8 on low-value rabbit holes.

6) Track output per $1 spent

This one hurt my ego but fixed my behavior fast.

Each day I ask:

What did I ship?
How much did it cost?
Was this worth it?

If output-per-dollar looks weak for 2–3 days, I tighten prompts and scope.

7) If attention is gone, stop buying more intelligence

When focus is dead, better models don’t save you.
They just make distraction more expensive.

If I catch myself tab-hopping, I pause, walk, and restart later.

My current baseline

After running this system consistently:

fewer token spikes
fewer doomscroll spirals
more shippable output per day

Not magic. Just visibility + constraints.

If you’re building with AI all day, treat token spend and attention like first-class resources. They leak together.

I tracked every AI coding session for 14 days — the expensive part wasn’t what I expected

Jamie — Tue, 10 Mar 2026 04:05:06 +0000

Two weeks ago I thought my AI spend problem was just "wrong model choice."

Turns out that was only half true.

I tracked every coding session for 14 days (time, context size, retries, model used, and cost), and the pattern was obvious:

Focused sessions were cheap
Distracted sessions were expensive
The biggest cost spikes came from context chaos + retry loops

What I measured

I logged:

Session start/end
Model used (Haiku/Sonnet/Opus + GPT variants)
Approx token cost per session
Number of retries before acceptable output
Whether I got distracted mid-session

The numbers

After 14 days:

Focused blocks (45-90 min): average cost $2.90/session
Fragmented blocks (constant tab switching): average cost $7.80/session
Retry-heavy sessions had ~2.4x more token spend than first-pass sessions

Same tools. Same developer. Same week.

The variable was attention.

3 changes that actually worked

1) Put cost in my face while coding

I stopped waiting for end-of-month surprises and started watching spend session-by-session.

I built/used TokenBar for this exact reason (Mac menu bar token/cost tracker, $5 one-time):
https://tokenbar.site

When you can see cost in real time, you naturally stop lazy retries.

2) Remove feed triggers instead of deleting entire apps

Cold turkey never lasted for me. I still needed DMs/groups/search.

So I started blocking just the algorithmic feeds while keeping utility surfaces. That’s where Monk Mode came from ($15 one-time):
https://mac.monk-mode.lifestyle

That single change reduced context-switching during coding blocks way more than generic app blockers.

3) Add a 10-second pre-prompt checklist

Before sending a big prompt:

Is this task actually Opus-worthy?
Did I narrow files/context first?
Am I asking one clear thing or three vague things?

Tiny habit, big cost impact.

The surprising part

I expected model tiering to be the hero.

But the bigger win was behavioral:
cleaner attention -> cleaner prompts -> fewer retries -> lower spend.

If your AI bill feels random, track two things at the same time:

cost per session
distraction during session

You’ll probably find the same multiplier I did.

If you’ve run this experiment yourself, I’d love your numbers.

I was “busy” for 12 hours and shipped nothing — here’s the system that fixed my focus + AI spend

Jamie — Tue, 10 Mar 2026 02:34:03 +0000

Last week I had one of those fake-productive days.

12 hours at my desk.
A million tabs.
Claude/Codex running nonstop.
At midnight I looked up and realized I had burned money and moved almost nothing forward.

So I changed one thing: I started treating attention and token spend as the same problem.

What was actually going wrong

I thought the issue was tooling.
It wasn't.

It was this loop:

Start coding task
Get stuck for 3 minutes
Open feed “for a second”
Come back with broken context
Re-prompt the AI with sloppy instructions
Pay for extra tokens + retries

I tracked it for a week and my unfocused sessions were consistently the most expensive sessions.

The 4-part system I use now

1) Kill the feed, not the app

I still need social apps/messages for work.
I don’t need the infinite algorithmic feed.

Blocking feed surfaces (instead of nuking entire apps) gave me the biggest focus win without breaking my workflow.

2) Watch cost while you build

End-of-month bills are useless for behavior change.
You need the feedback while you’re prompting.

I built TokenBar for this: a $5 Mac menu bar tracker that shows live token/cost usage so I can catch expensive prompt loops early.

3) Tier models on purpose

My default now:

cheap model for scaffolding + routine edits
stronger model only for architecture/debug dead-ends

Most dev tasks are not “max reasoning” tasks.
This alone dropped my waste fast.

4) Batch prompts before sending

If I’m interrupted, I don’t fire the next prompt immediately.
I write one clean, structured request first.

Cleaner prompt in = fewer retries = lower spend.

Results after 7 days

Deep-work blocks got longer
“accidental” doomscrolling collapsed
AI costs dropped because retries dropped
I shipped more in fewer hours

On the focus side, I use Monk Mode ($15, Mac) to block algorithmic feeds at the surface level.
Pairing that with TokenBar changed my output way more than any new model release did.

If you’re solo-building right now

Don’t only optimize prompts.
Optimize the environment around prompts.

If your attention is fragmented, your AI spend will reflect it.
If your attention is clean, your output and your costs both improve.

That was the whole unlock for me.