u/Bladebutcher_

I've been using Claude Code heavily over the past few months, and I kept wondering whether the feeling that long sessions gradually become less reliable was actually real or just confirmation bias.

Claude Code already stores detailed JSONL transcripts for every session, so I decided to build a tool that analyzes those logs instead of relying on anecdotes.

The result is contextrot.

It parses your local Claude Code session history and looks for several behavioral signals throughout a session, including:

• Failed or missed edits
• Retry loops
• File re-reads
• Self-corrections
• Tool errors

It then correlates those signals with context fill to determine whether failure rates actually increase as the context window grows.

Instead of always reporting a problem, it can return one of four verdicts:

• Context rot detected
• Edge rot
• No measurable context rot
• Not enough data

The attached screenshot is from my own sessions. Interestingly, it found no measurable context rot, my failure rate stayed essentially flat as context filled, which honestly wasn't what I expected. One of my design goals was to make sure the tool could also tell users when their workflow is not showing statistically meaningful degradation.

Everything runs completely locally:

• No API keys
• No telemetry
• No network requests
• Your Claude Code transcripts never leave your machine

It's open source (MIT) and free to use.

uvx contextrot

or

pip install contextrot

GitHub: https://github.com/Priyanshu-byte-coder/contextrot

I'd really appreciate feedback from other Claude Code users.

Some things I'm especially curious about:

• Do different models show different degradation patterns?
• Does heavy MCP usage affect the results?
• Are there failure signals you think I should be measuring that I'm currently missing?
• Would support for other coding agents (Codex CLI, Gemini CLI, OpenCode, etc.) be useful?

Since this is based on observational data rather than a controlled benchmark, I'm also happy to discuss the methodology or any implementation details if anyone is interested.

A few weeks ago I looked at my Downloads folder and realized it had turned into complete chaos.

300+ files. Old installers, random PDFs, ZIPs, screenshots... stuff I'd downloaded months ago and completely forgotten about.

I'd always tell myself, "I'll clean this up later."

Of course, later never came.

The problem is that when you download something, you already know whether it's important or just temporary.

That PDF from your bank? You'll probably want to keep it.

That random setup.exe you needed once? You'll probably never touch it again.

But by the time you're cleaning your Downloads folder weeks later, you have no idea what half the files are anymore.

So I built a Chrome extension called KeepTrack.

It quietly classifies every download as either Keep, Temporary, or Needs Review.

It doesn't use AI or send anything to a server. It's just a bunch of local heuristics.

It looks at things like:

• the file type (.pdf is usually worth keeping, .exe usually isn't)
• the filename (invoice, receipt, resume, etc.)
• where the file came from (your bank vs. a software download site)

Each signal contributes to a score.

If it's confident, it classifies the file automatically. If it's unsure, you get a small notification asking whether you want to keep it or treat it as temporary.

Temporary files stick around until you decide to clean them up. After two weeks they'll appear in the extension popup, where you can delete them individually or all at once. If you're feeling productive, there's also a Clean Up Now button.

A few things people here might care about:

• Everything runs locally.
• No accounts.
• No telemetry.
• Works offline.
• Open source (MIT).
• Built with plain JavaScript (Manifest V3 + service worker).
• On first launch it only shows you a preview of how it would classify your existing downloads before enabling anything.

I also made a small landing page because I thought it'd be fun to package it like a real product.

Website: https://priyanshu-byte-coder.github.io/keeptrack/

GitHub: https://github.com/Priyanshu-byte-coder/keeptrack

I'd genuinely love feedback—especially if you find files that get classified incorrectly. The rules are intentionally simple and easy to improve, so real-world edge cases are super helpful.

Used Supabase for auth, storage, and realtime on DevTrack —

a self-hosted GitHub activity dashboard.

Biggest lessons:

→ Row Level Security saved me from 3 potential data leaks

→ Realtime subscriptions made the leaderboard trivially easy

→ service_role key management is where most people mess up —

never expose it client-side

Features: year wrapped, commit streaks, PR throughput,

AI roasts, code personality report, friend leaderboard

Would love feedback from other Supabase builders —

especially on schema design for activity tracking.

repo: github.com/Priyanshu-byte-coder/devtrack