DEV Community: Alfred Emmanuel

I audited a month of my AI coding setup — 87% of it was dead weight

Alfred Emmanuel — Wed, 22 Jul 2026 04:34:31 +0000

Like most people using AI coding tools daily, I'd spent months installing things into Claude Code: skills, subagents, MCP servers, hooks, plugins. Every one of them felt essential at install time. None of them ever got reviewed again.

Then I mapped it.

That's my actual setup: 103 installed capabilities, and 90 of them never fired once in the last 30 days. The grey swarm around the ENGINEERING hub is months of "this looks useful" with zero follow-through.

The three questions nobody can answer about their own setup

What is my setup actually tuned for? More engineering than writing? Any research capability at all?
What am I paying for but never using? Installed skills and MCP servers load context into every session whether you use them or not.
Where are the overlaps and gaps? Two things doing the same job; whole capability areas with nothing.

You can't answer these by reading config files, because half the answer lives somewhere else: your session transcripts — what actually fired.

So I built Agent Atlas

One command:

npx agent-atlas-cli

It runs a four-stage pipeline, entirely on your machine: the scanner inventories ~/.claude (skills, subagents, MCP servers, hooks — read-only); the usage miner streams your local session transcripts and counts what fired in the last 30 days; the classifier scores every item across five capability axes — engineering, writing, research, design, ops — with one cheap Haiku call (or a fully-offline keyword mode if you don't set an API key); and the renderer writes a single self-contained HTML file: a force-directed map where node size = usage and grey = never used, a "tuning bar" summarizing your whole stack, and a diagnostics panel.

What it found on my machine

Dead weight with a price tag. A skill I'd installed and forgotten was loading ~150 tokens of description into the context of every session. Across 72 sessions in a month: ~11,000 tokens spent on something I never used once. The diagnostics panel lists every case like this, worst first. (The token figures are deliberately labeled as lower bounds — real MCP tool schemas can't be measured without connecting to the servers, and I'd rather under-claim.)

25 pairs of literally identical skills. The same plugin was cached under two different marketplace names, so every one of its skills existed twice. Invisible in any config file; obvious on a map when two nodes claim the same job and one has 31 uses while its twin has zero.

The installed-vs-used gap. My tuning bar says I installed a 43%-engineering stack but use a 36%-engineering one — the toggle between "installed" and "used" turns out to be the most honest single view of the whole thing.

The part I care most about: privacy

A tool that reads your AI config and transcripts had better be paranoid about where that data goes:

Read-only, local-only. No server, no accounts, no telemetry. The output is one offline HTML file.
The optional classification call sends item names and descriptions only — never transcripts, never code. Hook commands never leave the machine at all.
--rough mode skips the API entirely: nothing leaves your machine, period.
It's MIT-licensed and small enough to read in an afternoon: https://github.com/Pycomet/agent-atlas

How it was built (briefly)

Spec first, then four strict milestones — scanner+miner, classifier, renderer, diagnostics — each test-driven against a fake ~/.claude fixture tree, each verified against my real machine before merging. Before publishing I had the implementation adversarially reviewed; all six findings were confirmed and fixed (one of them was the plugin-cache bug that would have produced false dead-weight claims — the exact failure mode that kills trust in a tool like this). Built with Claude Code, npm-published via OIDC trusted publishing.

Try it on your own setup

npx agent-atlas-cli          # scan, classify, open the map
npx agent-atlas-cli --rough  # fully offline, no API key needed

Works with Claude Code today. The scanner sits behind a small adapter interface, so Codex CLI / Cursor / Gemini CLI adapters are the obvious next step — contributions very welcome.

I'd genuinely like to see what your map looks like — there's a "Share card" button in the page for exactly that.

Hey Devs! Ever found a way to clear out all unfinished projects?

Alfred Emmanuel — Thu, 25 Dec 2025 04:36:59 +0000

The Graveyard of My Unfinished Projects Led Me to Build This

Alfred Emmanuel ・ Nov 30

#ai #webdev #programming #productivity

The Graveyard of My Unfinished Projects (And the Ruthless Tool That Finally Made Me Finish)

Alfred Emmanuel — Sun, 30 Nov 2025 12:43:42 +0000

October 15th, 2024. 11:47 PM.
I’m staring at my GitHub profile. Forty-seven repositories. I start counting the dead ones:

AI-crypto-trader: 3 commits. Last touched: March 2023
VisionBoard-Pro: 7 commits. Last touched: January 2024
nasa-agi: 1 commit. “Initial commit.” That’s it.

(Dummy names here, but you get my point)

Forty-three corpses. Forty-three times I told myself “This is the one.”
Each project started the same way: late-night energy, new repository, perfect folder structure, README.md with ambitious roadmaps. That first-commit high.
Each one died the same way: quietly. Somewhere between the exciting architecture decisions and the boring implementation details.

I had become something I despised: a builder who doesn’t build. An engineer who only engineers excuses.

A Quick Translation
You don’t need to be an engineer to understand this.

Maybe your graveyard isn’t code.
Maybe it’s abandoned gym plans, half-read books, forgotten online courses, dusty business ideas, or that side hustle you keep restarting every January.

Different tools, same graveyard.

The Cost Calculation

Let me do the math that hurts:
Average time per abandoned project: ~20 hours

43 projects × 20 hours = 860 hours
That’s 107 eight-hour workdays
Or 21.5 work weeks
Or 5.4 months of full-time work

Thrown away. For what? For the dopamine hit of typing git init.

The Moment

That night, after completing a client project — actually finishing something someone paid me to do — I felt empty. After work, I was doing nothing creative. Just exercising, watching YouTube, scrolling. I could feel myself drifting further from the 1% I claimed I wanted to join.

The worst part? I was about to start another project. I could feel it. That familiar itch. “Maybe a new task management app…” my brain whispered.

No. Not this time.

The Comfortable Lies We Tell

Here’s what we don’t admit at standup meetings or in our Twitter threads:

We’re not “exploring ideas.” We’re avoiding execution.
We’re not “pivoting.” We’re running from complexity.
We’re not “learning new stacks.” We’re procrastinating on the hard parts.

And every productivity app enables us. They’re built by people like us, for people like us. They give us what we want: gentle reminders, inspirational quotes, fresh starts every Monday.

“You didn’t complete your tasks today? No worries! Tomorrow is a new beginning!”

No.

You failed. You made a commitment to yourself and broke it. Again. And tomorrow you’ll do the same thing unless something changes.

The Pattern

Week 1: “I’ll write for 2 hours daily.”
Week 2: “1 hour is more realistic.”
Week 3: “30 minutes is still progress.”
Week 4: “I’ll start fresh next month.”

Every app lets you adjust your goals downward. They call it “being realistic.” I call it negotiating with failure.

I realized I didn't need another gentle reminder. I didn't need an app that would pat my head when I pushed a deadline. I needed something that knew my patterns and refused to accept my bullshit.

So, I opened my IDE one more time. Not for the dopamine hit, but out of desperation. I was going to build one last thing, and its only job was to stop me from creating corpse number forty-eight.

Where It All Turned

That night, something snapped. Not in the cinematic, inspirational way. More like the dull crack you hear when a cheap plastic hanger gives up. I realized I’d become addicted to beginnings, allergic to endings, and dangerously skilled at convincing myself it was fine.

It wasn’t fine.

So I built something that didn’t let me negotiate with myself. No dopamine hits. No shiny dashboards. No “gentle nudge” nonsense. Just a tool that knows exactly when I’m slipping and calls me out before another project gets dragged into the cemetery.

That tool became Grindrpoof.

What Grindproof Actually Does

It doesn’t care about your mood. It doesn’t care about your excuses. It watches your behavior the way your IDE watches for missing semicolons.

If you commit less this week than last week, it notices.
If your goal slips from “build feature” to “rename folder,” it notices.
If you start a shiny new repo while your current project is starving in the corner, it absolutely notices.

And instead of patting your head, it tells you the truth:
You’re self-sabotaging again.

I didn’t build Grindproof for productivity nerds. I built it for people like me. People with graveyards. People who can architect a distributed system but somehow can’t finish a weekend project. People who are tired of being inspired and ready to be held accountable.

If You’re Reading This... Try It

If any of this felt uncomfortably familiar, then good. It means you recognize the pattern, the graveyard, the excuses. Grindproof was built exactly for people who build fast and quit faster.

So here’s the deal: it’s live at grindproof.co. Try it. Break it. Tell me where it punches too softly or too hard. I’m shaping this thing with real builders, not productivity influencers who wake up at 4 AM to drink lemon water.

If you want to see what else I’ve been up to, you can check out more of my work at codefred.dev.

Your feedback will help me turn it into something genuinely useful for all of us who want to finish more than we start.