DEV Community: Egor Fedorov

We optimize SQL queries, bundle sizes, API calls... but not how we talk to AI. Why?

Egor Fedorov — Tue, 24 Mar 2026 14:08:12 +0000

Here's a weird thing I noticed.

We spend hours shaving 200ms off a database query. We obsess over tree-shaking to save 12KB in a bundle. We cache API responses, debounce inputs, lazy-load images.

But when it comes to AI coding tools — the thing that's literally billing us per token — we just... let it rip?

I tracked everything for 107 sessions

I built a plugin for Claude Code that silently records every file read, every edit, every search. After 107 sessions, here's what I found:

37% of all tokens went to files that were never edited or meaningfully used
Claude re-read page.tsx 189 times across my sessions. 60 of those were pure duplicates
A single package-lock.json read? 45,000 tokens. Gone.
Total waste: ~1.9M tokens. At Opus pricing, that's roughly $28 I lit on fire in two weeks

And I consider myself a fairly intentional Claude Code user.

The question I keep going back to

Is this even a problem worth solving?

On one hand — $60/month in waste adds up. Especially if you're on a team of 10. That's $7,200/year just on files your AI read and forgot.

On the other hand — maybe the cognitive overhead of "optimizing" your AI workflow is worse than the waste itself. Maybe we should just let the model read whatever it wants and focus on the actual work.

I genuinely don't know. I built https://github.com/egorfedorov/claude-context-optimizer and I use it daily, but I catch myself wondering: am I solving a real problem or am I just scratching a developer's optimization itch?

What the tool actually does (30-second version)

It's a Claude Code plugin. Zero config. Runs silently via hooks.

The killer feature: Read Cache — a PreToolUse hook that blocks Claude from re-reading files it already has in context. Same file, same range, no changes on disk? Blocked. Claude adapts and works with what it has.

Already loaded tracker.js this session (983 lines, ~9.3K tokens saved).

File unchanged — no need to re-read!

It also does .contextignore (like .gitignore but for AI), token budgets with auto-compact, session replay, and a heatmap that shows where your tokens actually went.

Result: 30-60% fewer tokens per session from read deduplication alone.

But here's what I actually want to discuss

Three questions for the community:

Do you track your AI spending at all?

I'm genuinely curious. Do you know how much you spend per session? Per week? Or is it just a monthly credit card charge you don't think about?
Is "token efficiency" going to matter in 6 months?

Prices are dropping. Context windows are growing. Maybe optimizing tokens today is like optimizing assembly in the age of high-level languages — technically correct but practically pointless.
Who should solve this — the user or the model?
Should AI tools be smarter about what they read? Or is it on us to curate context? My plugin takes the "intercept and block" approach, but maybe the right answer is that models should just... stop being wasteful on their own.

The cynical take

Someone will say: "you built a tool to save $60/month and spent 3 weeks building it." And yeah, fair. The ROI on my time is probably negative.

But I've learned more about how AI coding actually works by building this than from any blog post or documentation. Watching the token flow in real-time changes how you think about human-AI collaboration.

And maybe that's the real value — not the $60, but understanding what's actually happening under the hood.

https://github.com/egorfedorov/claude-context-optimizer | MIT | Zero telemetry | All data local

Install: npx skills add https://github.com/egorfedorov/claude-context-optimizer

Drop your answers in the comments. Especially #2 — I go back and forth on this daily.

Update: my Claude Code token optimizer now blocks redundant reads. Here's the data from 107 sessions.

Egor Fedorov — Tue, 24 Mar 2026 10:09:41 +0000

Two weeks ago I posted I tracked where my Claude Code tokens actually go. 37% were wasted. — a plugin that tracks where your tokens go and shows you the waste.

34 reactions. Great feedback. But one comment stuck with me:

"The real unlock for me was getting a live counter visible all session instead of only doing post-mortems, because it changes behavior in the moment before waste happens." — @henrygodnick

He was right. Tracking is nice. Preventing is better.

So I built v3.1 — and the plugin now actively blocks wasted reads instead of just reporting them.

The big one: Smart Read Cache

The #1 waste pattern I found in 107 sessions: Claude re-reads the same file multiple times.

page.tsx — read 189 times across my sessions. 60 of those were pure duplicates. That's 130K tokens burned on a file Claude already had.

So I added a PreToolUse hook that intercepts every Read call:

// First read? Always allow.
if (!entry) return allow();

// File changed on disk? Allow.
if (currentMtime !== entry.mtime) return allow();

// Different section? Allow.
if (!isRangeCovered(entry.ranges, offset, end)) return allow();

// Same file, same range, unchanged. Block it.
return { decision: 'block', reason: 'Already loaded — file unchanged.' };

When it blocks, Claude sees:

Already loaded tracker.js this session (983 lines, ~9.3K tokens).
File unchanged. Use offset/limit to read a specific section, or Edit to modify it.

And Claude adapts — it stops trying to re-read and works with what it has.

It's not dumb about it

Three edge cases that matter:

Compaction — Claude actually lost the context. Cache clears. Re-reads allowed.
Edit/Write — file content changed. That file's cache invalidates.
Partial reads — tracks offset/limit ranges. Only blocks if the exact range was already covered.

Real numbers: 107 sessions analyzed

I ran a retroactive analysis on all my existing sessions — what would Read Cache have saved?

Sessions analyzed:              107
Total tokens tracked:           23.5M
Redundant reads found:          1,225
Tokens that would have been saved: 1.9M (8.0%)

Top sessions by savings:

Session	Saved	Total	%
Football Slot	247K	362K	68%
claude-context-optimizer	62K	210K	29%
Engine3.0	63K	329K	19%
DJ Beat Drop	39K	276K	14%

Top re-read offenders:

File	Total reads	Blocked	Tokens saved
`page.tsx`	189	60	130.9K
`GameInfoModal.svelte`	23	6	56.8K
`variables.css`	34	26	49.2K
`client.ts`	46	22	48.8K
`types.ts`	60	30	41.6K

That's 1.9M tokens I would have saved. At $15/M on Opus — roughly $28.50 over two weeks, or ~$60/month.

What else is new in v3.1

Project Anatomy (/cco-anatomy) — generates a one-file codebase map:

# Project Anatomy: my-app
Generated: 2026-03-24 | 31 files | ~46K tokens if all read

| Path | Lines | ~Tokens | Type |
|------|-------|---------|------|
| src/tracker.js | 984 | 9.1K | source |
| src/export.js | 398 | 3.7K | source |
...

Claude reads this instead of opening 20 files to understand your project.

45 unit tests — the plugin is now properly tested. npm test runs in under 60ms.

Honest README — I renamed "Interactive Dashboard" to "HTML Dashboard Export" because that's what it actually is. No more marketing fluff.

Install / update

First time:

npx skills add https://github.com/egorfedorov/claude-context-optimizer

Already have it:

claude plugin update claude-context-optimizer@egorfedorov-plugins

Zero config. Zero telemetry. All data stays local.

GitHub repo — MIT licensed.

The v2 post got 34 reactions. Let's see if blocking redundant reads is worth a star.

I tracked where my Claude Code tokens actually go. 37% were wasted.

Egor Fedorov — Mon, 09 Mar 2026 06:34:30 +0000

Last month I hit $180 on my Claude Code bill. I use Opus daily — refactoring, bug fixes, code reviews, building features. But something felt off. Sessions were getting expensive, and I couldn't tell why.

So I did what any developer would do: I built a tool to find out.

## The experiment

I started manually logging which files Claude reads during a typical session. After a week of tracking, the pattern was clear:

Out of every 10 files Claude reads, only 6-7 actually matter. The rest — configs, READMEs, lock files, type definitions — get loaded into context and never referenced again.

Quick math:

package.json read "just in case" → 120 tokens, every time
A README for context → 2,400 tokens, used once, forgotten
tsconfig.json → 400 tokens, never needed

At ~$15/M tokens on Opus, 30-50% of my bill was going to irrelevant context.

## The plugin

I built claude-context-optimizer — a Claude Code plugin that silently tracks every file read, edit, and search. No configuration. No setup. Just install and forget.

It hooks into Claude Code's tool pipeline (PostToolUse, SessionStart, SessionEnd) and records:

Which files were read and how many times
Which files were actually edited (high value)
Which files were read once and never used (waste)
Estimated token count per file (~4 tokens/line)

## Context Heatmap

Run /cco and see exactly where your tokens went:

Green bars = files that were actually edited or referenced multiple times. Red bars = read once, never used. That README.md eating 2,400 tokens? Pure waste.

## Efficiency Score

Run /context-digest for a weekly report card:

You get a grade (S through F) based on four metrics:

Context Precision — how many files you read were actually useful
Edit Efficiency — ratio of edits to reads
Search Accuracy — are your Grep/Glob searches finding the right files?
Focus Score — are you re-reading files too often?

Plus real cost breakdowns: total spent, wasted, and saveable per month.

## Token ROI Report

/cco-report gives you the full picture across all tracked sessions:

Trends over time, top wasted files, top useful files, and specific recommendations.

## How it works under the hood

The architecture is simple — no build step, no dependencies, just Node.js scripts:

Every session gets a JSON file tracking per-file reads, edits, and usefulness. When a session ends, the plugin updates a global patterns database that learns which files are consistently useful or wasted across sessions.

## The features I didn't expect to need

Token Budget — /cco-budget set 80000 sets a token limit with real-time warnings at 50/70/85/95%. Knowing you're at 70% makes you think twice before reading another file "just in case."

Git-Aware Suggestions — /cco-git analyzes your current diff and suggests files you'll actually need. Combined with historical patterns, it knows that when you touch auth-service.ts, you almost always need user.model.ts too.

Context Templates — /cco-templates create bug-fix saves a set of files you always need. Next time, /cco-templates apply bug-fix loads exactly the right context.

## Results after 2 weeks

Waste ratio dropped from ~40% to ~15%
Average session cost decreased by roughly 25%
Sessions feel faster — less context means faster responses
I stopped reading README.md and package.json reflexively
Created 3 templates that save ~5 minutes of setup per session

## The meta part

The entire plugin — 2,500+ lines of code, 8 slash commands, SVG visualizations, README — was built in a single Claude Code session using Opus. Claude built the tool that optimizes Claude. Make of that what you will.

## Try it

Install in one command:

git clone https://github.com/egorfedorov/claude-context-optimizer.git ~/.claude/plugins/claude-context-optimizer

No npm install, no build, no config. MIT license. Zero telemetry — everything stays local.

GitHub: egorfedorov/claude-context-optimizer

Stars and PRs welcome.

What's your Claude Code bill looking like? I'm curious if others have noticed the same waste patterns.

I Built a Desktop Tamagotchi Cat with AI Brain in Swift - and It Lives on My macOS Doc

Egor Fedorov — Sun, 08 Mar 2026 03:05:15 +0000

You know that feeling when you're coding at 2 AM and wish someone was there with you?

Meet Murchi — a kawaii desktop cat that lives on your macOS dock, walks around your screen, reacts to your music, and now can actually talk to you powered by Gemini AI.

## What is this?

Murchi is a desktop Tamagotchi for macOS. A tiny animated cat that:

🐾 Walks on your Dock like it's a shelf
🎵 Detects Apple Music / Spotify and dances (or hates your music 25% of the time)
😿 Goes to the corner and cries if you punish it
🖱️ Dangles from the scruff when you drag it
💬 Chats with you via Gemini AI — in character, as a cat
🐟 Needs feeding, bathing, playing — classic Tamagotchi loop

It sits in your menu bar as =^.^= and just... lives there.

The Tech Stack (it's cursed and I love it)

The entire app is one Swift file. 7000+ lines. No Xcode project. No storyboards. No SwiftUI.

Pure AppKit — NSPanel, NSImageView, raw CGContext drawing
SVG strings rendered to NSImage — every animation frame is an SVG built in code
No sprites, no assets — the cat is literally constructed from bezier paths and hex colors
Gravity physics, dock detection via CGWindowListCopyWindowInfo
Music detection via AppleScript (tell application "Spotify" to player state)
AI chat via Gemini 2.0 Flash REST API with URLSession
Built and packaged with a 100-line build-app.sh — no Xcode needed

The AI Part

The cat has personality. When you chat with it, Gemini knows:

The cat's name, level, and evolution stage
Current mood, hunger, happiness stats
It responds in 1-3 sentences with cat sounds ("mrrrow~!", "purrr")

  let systemPrompt = """
  You are Murchi, an adorable kawaii desktop cat.
  Your personality: playful, cute, a bit mischievous.
  Keep responses SHORT. Use cat sounds like "mrrrow", "mew".
  Current mood: \(stats.mood). Hunger: \(Int(stats.hunger))%.
  """

Users can plug in their own Gemini API key in settings, or it works out of the box.

The Entire Thing Was Built with Claude Code

I'm not going to pretend — this project was built almost entirely in conversation with Claude Code (Anthropic's CLI agent). I described what I wanted, it wrote the code, I tested, gave feedback, it fixed.

The workflow:

Me: "I want a cat that walks on the dock"
Claude: writes 2000 lines of SVG renderer
Me: "the cat is orange, it should be peach"
Claude: rewrites entire renderer
Me: "now make it talk with AI"
Claude: adds Gemini integration in 15 minutes

Every commit in the repo is co-authored with Claude. This is what AI-assisted development actually looks like — not replacing the developer, but making ambitious side projects actually possible on a weekend.

Try It

It's free, open source, and works on any Mac (macOS 12+):

⬇️ https://github.com/egorfedorov/murchi/releases/latest

🐙 https://github.com/egorfedorov/murchi

⬇️ https://murchi.pet

No Xcode needed to build — just bash build-app.sh.

If you've ever wanted a pet on your desktop that judges your music taste and occasionally poops on your screen — this is it.

mrrrow~! 🐱