Search for a command to run...
I spent months trying every Claude Code add-on I could find, and these are the seven I now refuse to code without, plus twenty-one more worth knowing
WhoAmI => notes.sohag.pro/author
No comments yet. Be the first to comment.
I had a solid list of reasons my life wasn't moving faster, until a grainy old lecture pointed out the one name missing from it
The finale isn't a victory lap. It's the story of the control I shipped that did nothing, the footgun still sitting in my demo, and the handful of things I'd keep exactly as they are.
How do you hold a large payment for a second pair of eyes without ever letting the unapproved money touch a balance, and how do you stream that decision to the outside world without standing up a broker?
How do you show the total under a parent account when the whole system refuses to store a balance? A recursive query, a trigger that refuses to draw a circle, and a rule about what actually has to sum to zero.
Every time I wanted to change an FX rate I had to edit a file on the server and restart the app. So I moved rates and markup into a live admin API, and then audited it hard enough to find the bug that quietly undid the whole thing.
Last week I asked Claude Code to add a small feature to a project I'd been away from for a few days. It re-read half the repo to remember what it was looking at, wrote me three paragraphs explaining a two-line change, and handed back a settings page with the exact purple-on-white gradient every AI on earth seems to love. The next morning I opened a fresh session and it had forgotten all of it. We started from zero again.
None of that is Claude being bad at its job. It's Claude out of the box, with none of the sharp edges filed down. The default setup is the floor, not the ceiling, and the gap between the two is where all the fun lives.
Here's the thing: every one of those annoyances has already been fixed by someone in the community, and most of the fixes are free, open source, and install in one command. I've spent the last few months trying an embarrassing number of them. This post is the shortlist: 28 tools grouped by the problem they solve, with the seven I run every single day marked clearly so you can skip straight to my setup if that's all you want.
Let me show you the shape of the problem first, because it makes everything after it click.
Strip away the details and almost every Claude Code frustration falls into one of four buckets. It forgets. It's wordy and expensive. It works blind. And its taste is generic. Here is how my daily seven map onto those gaps:
Claude Code, straight out of the box
|
+-------------+---------+-------+----------------+
| | | |
v v v v
forgets burns tokens reads the ships
the last on every codebase generic
session single reply blind purple UIs
| | | |
v v v v
claude-mem caveman + RTK understand- frontend-design
(memory) (budget) anything (taste)
(a map)
+------------------------------------+
| superpowers + swift-lsp sit on |
| top: a process, and real code |
| intelligence for what you ship |
+------------------------------------+
That's the whole thesis. Give Claude a memory, a budget, a map, some taste, a process, and real language smarts, and the late-night session I described stops happening. Now let's go tool by tool.
If you copy nothing else from this post, copy this. These seven fix the four gaps above, and I genuinely notice when one of them is missing.
| Tool | What it does for me |
|---|---|
| superpowers | Forces a spec, then a plan, then tests, then review, instead of cowboy coding |
| frontend-design | Kills the generic AI look and makes UIs feel designed |
| swift-lsp | Real Swift code intelligence for my iOS work |
| caveman | Trims about 65% of the words out of Claude's replies |
| claude-mem | Gives Claude a memory that survives between sessions |
| understand-anything | Turns any codebase into a map I can explore |
| RTK | Shrinks noisy command output before it eats my context window |
Everything below is grouped by job. The daily-seven are marked with a star so they're easy to spot.
The single biggest upgrade to AI coding isn't a smarter model. It's making the model slow down and follow a process. These tools stop Claude from sprinting to code before it understands what you actually asked for.
superpowers (by Jesse Vincent) is a skills framework plus a full way of working that loads into your agent on its own. Its skills cover test-driven development with a strict red, green, refactor loop, step-by-step debugging, writing a spec before any code, planning and executing that plan, code review, and keeping work isolated in git worktrees. The important bit: these are described as mandatory workflows, not gentle suggestions. They kick in automatically, and Claude can hand each task to a fresh subagent that reviews the work twice, once for "does this match the spec" and once for "is the code any good."
Picture asking it to "build me a rate limiter." Instead of dumping code, Claude asks you the questions that pin down a real spec, gets your sign-off, spins up a clean worktree, writes the failing tests first, then builds it piece by piece with a reviewer checking between steps. It's the difference between a junior who guesses and a senior who checks.
Install with /plugin install superpowers@claude-plugins-official. It's MIT licensed.
Why it's my number one: every other tool here makes Claude faster or cheaper. This one makes it correct, and that pays off over and over.
gstack is Garry Tan's actual setup, and it turns Claude Code into a team of 23-plus specialist roles running a real sprint: think, plan, build, review, test, ship, reflect. You get /office-hours for product questions, /review playing a staff engineer hunting bugs, /qa that opens a real browser to find and fix them, /cso for a security audit, and /ship to run tests and open the pull request. Each command feeds the next.
A solo founder types "build a daily briefing app for my calendar," runs /office-hours, and gstack reframes it as a personal chief-of-staff app, runs its plan reviews, writes a couple thousand lines, catches a race condition in review, finds a live bug in the browser during QA, and ships the PR with new tests attached. Install by cloning it into ~/.claude/skills/gstack and running its setup script. MIT.
agent-skills is a pack of 23 engineering skills that put senior habits behind seven commands: /spec, /plan, /build, /test, /review, /code-simplify, and /ship. Each one has clear checks and what the author calls anti-rationalization tables, which are there to stop the agent talking itself out of writing tests. It bakes in well-known engineering practices like the test pyramid and trunk-based development.
Type /ship and it runs a pre-launch checklist, confirms the tests actually pass by reading the real output instead of trusting a vibe, and pushes a staged rollout with a rollback plan. Install via /plugin marketplace add addyosmani/agent-skills. MIT.
If gstack is a team and Osmani's pack is a rulebook, everything-claude-code is the whole factory: 60 agents and 232 skills, plus hooks, rules, and MCP configs from an Anthropic hackathon winner, polished over more than ten months of daily use. It covers token savings, memory that carries across sessions, and a learning loop that pulls your recurring patterns into new skills. Install through npm as ecc-universal or as a Claude Code plugin. The core is MIT with a paid Pro tier.
Where the others hand you commands, this 15-skill collection teaches you why they work. It covers context decay, compression, multi-agent patterns, memory systems, and evaluation, and it's cited in academic research. When your long-running agent starts slipping after 40 turns, you turn on its context-degradation and compression skills, spot that the model is losing track of the middle of a long context, and apply a fix that keeps the task state instead of just chopping text off. Install via its marketplace entry. MIT.
get-shit-done by TÂCHES is a small system that turns a loose feature request into a written spec before Claude writes a line. One heads-up: the original repo was archived, and the work continues as GSD Core at open-gsd/gsd-core, so point your install there. MIT.
Long sessions die two ways: the bill, and the context window filling up with junk. Wordy replies and noisy command logs eat both. These tools win them back. A quick honesty note: the percentages below are each project's own numbers, and real savings swing a lot depending on what you're doing.
caveman makes Claude, in its own words, "talk like caveman." It drops filler words while keeping the full technical detail, for an average cut of about 65% in output tokens in its own tests. You get four levels, helper commands like /caveman-stats that show real dollar savings, and a status-line badge counting the tokens you've saved over time.
Say you're debugging an auth bug and tired of paragraph-long answers. After /caveman, the reply comes back as "Bug in auth middleware. Token expiry check uses < not <=. Fix:" and then the fix. Same information, roughly 75% fewer words, and honestly faster to read. Install with its one-line script, then type /caveman. MIT.
The reason I keep it on: it only trims the output, never the thinking. You lose the fluff and nothing else, and over a full day of coding that's real money.
Where caveman shrinks what Claude says, RTK, short for Rust Token Killer, shrinks what Claude reads. It's a single small binary that sits in front of 100-plus dev commands, things like git, grep, cargo, docker, and kubectl, and filters, dedupes, and trims their output before it reaches the model. That's 60 to 90% fewer tokens at almost no overhead. The clever part is an auto-rewrite hook that quietly turns git status into rtk git status, so you get the savings without changing a thing about how you work.
During a long session you run cargo test again and again. Without RTK, each failure dumps 200-plus lines into your context. With the hook installed, Claude runs rtk cargo test and gets back a 20-line summary of just the failures. Install with brew install rtk, then rtk init -g and restart. Apache-2.0.
caveman and RTK together hit both sides of the token budget. Set them up once and forget they exist, which is exactly what you want from a tool like this.
headroom is a local-first layer that compresses everything the agent reads: tool output, logs, files, and history. It claims 60 to 95% fewer tokens with accuracy holding steady, and the compression is reversible, so it caches the originals and the model can pull them back when it needs them. Run headroom wrap claude before a big refactor and a 100-result code search that would have cost you nearly 18,000 tokens shrinks to under 1,500. Install via pip install "headroom-ai[all]". Apache-2.0.
Claude has two big blind spots. It forgets everything between sessions, and it explores your codebase by opening files one at a time, hoping to stumble onto the right one. These fix both.
claude-mem captures what Claude does each session, compresses it with AI, and feeds the relevant parts back into future sessions. Hooks record notes automatically, everything lands in a local database with a live web viewer, and a search skill lets Claude look things up cheaply. Private tags keep anything sensitive out.
Say you fixed a nasty race condition last week. In a fresh session you ask "how did we handle the payment race condition?" and instead of working it out from scratch, claude-mem surfaces the old notes and Claude picks right back up. Install with npx claude-mem install (use the installer, not the bare npm package). Apache-2.0.
Every other tool here makes a single session better. This one makes tomorrow's session better. It's the closest thing I've found to Claude actually learning your project.
Understand-Anything turns any codebase into an interactive knowledge graph. Run /understand and a five-agent pipeline scans the repo, mixes exact parsing with AI summaries, and saves a graph you can commit alongside your code. Then /understand-dashboard gives you a map you can pan and zoom, with search, guided tours, and impact analysis for a change.
Picture joining a team with a 200,000-line repo. You run /understand, then /understand-onboard for a guided tour in dependency order, then ask /understand-chat "how does the payment flow work?" and trace it visually before touching a single line. Install via its marketplace entry. MIT. Fair warning: the first run on a big repo burns a lot of tokens, so plan for that once.
Getting up to speed on unfamiliar code is where I waste the most time, and this turns "read 500 files" into "explore a map."
codegraph is a fully local MCP server that indexes your code into a graph, so Claude queries the structure instead of grepping through files. In its tests that means about 92% fewer tool calls and roughly 71% faster exploration than the built-in search. Before renaming a widely used method, you have Claude call its impact tool to instantly list every caller across a 4,000-file repo, so nothing breaks. Install with npx @colbymchenry/codegraph. MIT.
graphify reads a folder of anything, code, docs, PDFs, even screenshots and diagrams, and builds a knowledge graph that sticks around. It flags surprising links between things and tags every connection by how confident it is. A researcher keeps a folder of papers, code, and whiteboard photos, runs /graphify on it, and it points out that an idea in a paper connects to a module in their code, a link they'd never have spotted by hand. Install via pip install graphifyy. Works with Python 3.10-plus.
For private knowledge bases at scale, LightRAG (from an EMNLP 2025 paper) builds a knowledge graph from your documents and searches it more thoroughly than plain vector search. A team indexes 5,000 internal contracts and asks "which vendors have auto-renewal clauses?" and it follows the links between entities to give cited answers that span contracts, instead of a handful of isolated matches. Install with uv tool install "lightrag-hku[api]". MIT.
You know the look: purple gradient, Inter font, three cards in a row. Every AI reaches for it. These three give your output some actual character.
Anthropic's own frontend-design skill nudges Claude toward deliberate, intentional design instead of cookie-cutter output. It pushes real choices about color, type, and layout that fit the brief, and it openly fights the usual AI slop. Ask for a landing page for a specialty coffee brand and, instead of the default purple hero, you get a warm editorial layout with a thoughtful serif-and-mono pairing and an accent palette that actually suits the brand. Pick frontend-design from the official Claude Code plugin menu.
This is the single biggest change to how my frontends look. One toggle and the output stops screaming "an AI made this."
ui-ux-pro-max builds a full design system from a plain request. Under the hood it carries 161 industry rules, dozens of UI styles, palettes, and font pairings, and it hands back a pattern, colors, type, and a pre-delivery accessibility checklist. Prompt "build a landing page for my beauty spa" and it produces a calm pink, sage, and gold system with a matching serif pairing, flags what to avoid, and builds against that checklist. Install via its marketplace entry, or the CLI.
taste-skill is a pack of anti-slop skills with three dials you set from 1 to 10: variance, motion, and density. Ask Claude to redesign a bland SaaS page, make reference comps first, then let the skill build an off-center layout with scroll-driven motion, turning the variance and motion dials up for something far more distinct than a centered template. Install with npx skills add. Works with React, Vue, and Svelte.
By default Claude edits code as plain text. Wiring in a real language server means its edits are grounded in the actual type system, not a guess.
swift-lsp wires Apple's SourceKit language server into Claude Code, giving it real intelligence for Swift files: go-to-definition, find references, hover docs, refactoring, and live diagnostics. Because it uses the language server that ships with the Swift toolchain, there's nothing extra to install if you already have Swift.
Refactoring an iOS view model, I ask Claude to rename a method across the module. With swift-lsp it uses find-references to hit every call site and sees the compiler's diagnostics right away, instead of guessing and quietly breaking the build. Install from the Claude plugins marketplace; it needs the Swift toolchain.
For iOS work this is a must. Text-level edits on a typed language are a recipe for silent breakage, and the language server keeps Claude honest.
Microsoft's markitdown converts PDF, Word, PowerPoint, Excel, images, audio, HTML, and even YouTube links into token-light Markdown that keeps the headings, lists, and tables. Run a client's 40-page PDF spec through it, then hand the Markdown to Claude to write matching API stubs, with the tables intact, which a raw text extractor would have flattened. Install with pip install 'markitdown[all]'. MIT.
Beyond the editor, these connect Claude to real workflows, real browsers, and finished output.
n8n-mcp gives Claude deep knowledge of n8n's automation nodes, 1,650 of them indexed, with thousands of templates and validation so it sets nodes up correctly instead of inventing parameters. Ask it to "post new Stripe payments to Slack" and it finds a matching template, checks the Slack node has the field it needs, and deploys the workflow. Hosted with a free tier, or self-host via Docker. MIT.
dev-browser gives Claude a real browser by running sandboxed scripts against Playwright, with no access to your host filesystem or network. Tell Claude to check a login flow and it opens staging, fills the form, screenshots the dashboard, and reads back the title, all safely boxed in. Install with npm install -g dev-browser.
Remotion lets you make videos with code using React, where CSS, data, and animation all drive the frames. Build a "year in review" feature that renders a personal video for each user by passing their stats as props, and you get thousands of unique videos from one setup. Start with npx create-video@latest. Note that some commercial uses need a company license.
If your notes live in Obsidian, obsidian-skills (by Steph Ango, with 38,000-plus stars) teaches your agent the formats behind it: Obsidian-flavored Markdown, Bases, JSON Canvas, the Obsidian CLI, and a tool for pulling clean Markdown out of web pages. Point Claude at your vault and say "turn my scattered meeting notes into a Base that tracks action items by owner and due date," and it writes valid syntax instead of mangling the markup. Install via /plugin marketplace add kepano/obsidian-skills. MIT.
The supporting cast: keeping the agent from doing something dangerous, finding the next tool, and leveling yourself up.
agentguard blocks dangerous actions at the hook level, not as a polite instruction the model might ignore. It steps in to protect your .env and secrets, enforces protected-branch rules, and offers opt-in packs for Docker, AWS, Kubernetes, and more. When the agent tries to read .env or force-push to main, the hook stops it before it runs, and a check command confirms the guardrails are still in place in CI. Install by cloning it and running its installer. Needs bash and jq.
awesome-claude-code is the big curated list of skills, hooks, slash commands, and plugins, all checked for quality and originality. When you want the next tool after this post, start there. Setting up a new project, you browse it, grab a well-reviewed pre-commit hook and a code-review command, and drop both into your config.
last30days searches Reddit, X, YouTube, Hacker News, GitHub, and more all at once, ranks results by real engagement instead of SEO, and pulls it into one grounded brief. Before a call you run it on a person's name and get their recent work, their GitHub activity, and a lively forum debate, none of which is on their LinkedIn. Install via its marketplace entry. MIT.
ai-engineering-from-scratch is a free course of 435 lessons that builds AI by hand, from linear algebra up to agent swarms, where every lesson ships something reusable. You can call an API but can't explain attention, so you run its placement quiz, land in the transformers phase, build attention from the raw math, and install that lesson's MCP server into your own stack. Clone it and run the install script. MIT.
The one tool here that's an alternative to Claude Code rather than an add-on: DeepSeek-Reasonix is a terminal agent built around DeepSeek, a single small binary tuned to keep costs low on long sessions. Worth knowing about if you want a cheap, self-hosted agent to run alongside Claude for lower-stakes work. Install with npm i -g reasonix.
If you just want to copy what I run, here it is:
# 1. superpowers, the process
/plugin install superpowers@claude-plugins-official
# 2. frontend-design, pick it from the official plugin menu
# 3. swift-lsp, install from the Claude plugins marketplace (needs Swift)
# 4. caveman, shorter replies
curl -fsSL https://raw.githubusercontent.com/JuliusBrussee/caveman/main/install.sh | bash
# 5. claude-mem, memory across sessions
npx claude-mem install
# 6. understand-anything, a codebase map
/plugin marketplace add Egonex-AI/Understand-Anything
/plugin install understand-anything
# 7. RTK, smaller command output
brew install rtk && rtk init -g
Claude Code out of the box is a talented junior with no memory and no process. The tools here give it a memory, a budget, a map, some taste, a process, and real smarts for the language you actually ship. That late-night session I opened with, the one where it forgot everything and handed me a purple settings page, mostly doesn't happen anymore. Not because the model got smarter overnight, but because I stopped asking it to work with one hand tied behind its back.
Install the seven. Then poke through the rest and steal what fits. Your future self, the one who isn't re-explaining the codebase for the fortieth time, will thank you.
One honest caveat before you go: the token-savings numbers here are each project's own, and they vary a lot by workload. Treat them as "meaningfully less," not gospel.