Five free, open-source Claude Code plugins that cut token waste, add persistent memory, and eliminate generic AI output — install all five in one sitting.
This guide is reviewed for clarity, service accuracy, and AI-search readability. The next quarterly content review is tracked internally before unsupported metrics or client proof are added.
5 Claude Code Plugins That Make You Dangerous as a Solo Founder
The default Claude Code setup is fine. But five extensions separate builders who hit rate limits and lose session context every day from builders who just keep shipping.
None of these cost anything. All open-source. This guide walks you through installing all five in one sitting — copy-paste commands, verification steps, and a decision table so you know which one to install first.
The 5 Plugins at a Glance
| # | Plugin | Problem It Solves |
|---|---|---|
| 01 | Caveman | Verbose Claude responses burn your token budget — Caveman compresses output ~65% |
| 02 | Claude-Mem | Every new session starts blank — Claude-Mem gives Claude persistent memory |
| 03 | Taste-Skill | Claude-generated UIs look generic — Taste-Skill applies opinionated design judgment |
| 04 | Context7 | Claude codes against stale library docs — Context7 injects live documentation |
| 05 | CC-Gemini | Large codebases exhaust Claude's context window — CC-Gemini routes big tasks to Gemini |
Plugin 01 — Caveman
Problem it solves: Rate limits from token-heavy responses. Claude's default output is thorough and verbose — headers, summaries, preambles, pleasantries. For a solo founder running 8–12 hour build sessions, that verbosity burns your token budget before you're done shipping.
How it achieves ~65% reduction: Caveman rewrites Claude's response style at the system level. It strips:
- Articles (a, an, the)
- Filler phrases (basically, essentially, just, simply, actually)
- Pleasantries (Sure! I'd be happy to…, Of course…, Certainly…)
- Recap summaries at the end of responses (you can read the diff)
Technical content is never touched. Code blocks are never compressed. The result is the same information in roughly 35% of the original tokens.
Three modes:
- Lite — drops obvious filler, keeps sentence structure mostly intact. Good for mixed sessions.
- Full — caveman fragments, drops articles, aggressive filler removal. The ~65% savings figure. Best for active build sessions.
- Ultra — maximum compression for rapid-fire terminal work. Responses become terse, direct fragments.
Install:
bashclaude plugin install caveman
Or: Claude Code settings → Plugins → search "Caveman" → Install.
Switch modes mid-session:
prompt/caveman lite /caveman full /caveman ultra
Turn it off:
promptstop caveman
Verification: After installing, type /caveman full then ask Claude "What is a REST API?" — the response should arrive in short fragments without articles or preambles. If you still see "Sure! I'd be happy to explain…" the plugin isn't active. Check that it appears in claude plugin list.
Plugin 02 — Claude-Mem
Problem it solves: Lost context. Every new Claude Code session starts blank. You re-explain your stack, your conventions, your decisions — every single time. Claude-Mem ends that cycle.
How session context is captured and injected: Claude-Mem runs as a background service. During a session, it tracks decisions made, patterns established, and preferences confirmed. At session end (or when you trigger /reflect), it compresses what happened using AI summarization and writes structured memory files locally. On the next session start, it scans the memory index and injects the relevant files into Claude's context automatically.
MEMORY.md structure: The index file lives at ~/.claude/projects/<project-name>/memory/MEMORY.md. Each line is a one-line pointer to a detailed memory file:
markdown- [Auth Pattern](auth-pattern.md) — JWT with 7-day expiry; refresh on every authenticated request - [DB Conventions](db-conventions.md) — all queries through lib/db.ts; no raw SQL in route handlers - [User Context](user-role.md) — solo founder, strong Python background, new to TypeScript
Individual memory files use a frontmatter format:
markdown--- name: auth-pattern description: JWT auth setup and refresh convention for this project metadata: type: project --- Use JWT tokens with 7-day expiry. Refresh on every authenticated request. Store in httpOnly cookies only — never localStorage.
Memory types: user (who you are, your background), feedback (what to avoid or repeat), project (decisions, deadlines, context), reference (where to find external info).
Works with Claude Code, Codex, and Copilot: Claude Code uses the memory index natively. For Codex sessions, point the workspace context at the same memory/ directory. For GitHub Copilot, export the memory index to a .github/copilot-instructions.md file — Claude-Mem can generate this automatically.
Install (recommended):
bashnpx @claude-mem/cli install
Follow the interactive prompts to connect it to your Claude Code workspace.
Alternative — Plugin Marketplace: Claude Code settings → Plugins → search "Claude-Mem" → Install.
Verification: After install, start a fresh Claude Code session and type:
prompt/reflect
Claude should scan the session for memory-worthy learnings and offer to save them. If /reflect returns an unknown command, the plugin isn't loaded. Run claude plugin list to confirm.
Plugin 03 — Taste-Skill
Problem it solves: Generic AI aesthetics. Default Claude UI output looks like every other AI-generated interface — centered layout, flat Tailwind defaults, uniform spacing, blue button on a grey card grid. Taste-Skill applies a curated design sensibility that shifts Claude's output baseline from "generated" to "considered."
What "opinionated design taste" means in practice:
Without Taste-Skill, ask Claude to build a pricing page and you get: three-column card grid, Inter font at default scale, blue CTA buttons, identical padding on everything.
With Taste-Skill active, the same prompt produces: asymmetric layout, intentional typographic hierarchy, restrained color use, components with visual rhythm — output that looks like it was designed rather than assembled from defaults.
What it changes vs default Claude output:
- Typography: tighter control over scale, weight contrast, and line height — less "all body text, same size"
- Layout: breaks the grid-of-cards default; introduces variation in structure and rhythm
- Color: more restrained choices; less blue-on-white reflex
- Components: less Bootstrap-brain, more design-system thinking
What it doesn't change: It doesn't rewrite your existing CSS, override your brand, or force a framework. It shifts Claude's generative defaults when building UI from scratch.
Install:
bashgit clone https://github.com/Leonxlnx/taste-skill ~/.claude/plugins/taste-skill
Then follow the repo README to register it as an active skill, or add it through Claude Code settings → Skills → Add Local Skill.
Verification: Ask Claude to "build a pricing page component in React with three tiers." Without Taste-Skill: three equal cards, blue buttons, default Tailwind spacing. With Taste-Skill active: visible typographic scale difference, non-identical card treatment, layout differentiation. If output looks identical to the default, run /taste-audit or check the active skills list in your Claude Code settings.
Plugin 04 — Context7
Problem it solves: Stale library documentation. Claude's training has a cutoff date. When you ask it to implement current Next.js App Router patterns, the latest Supabase Auth helpers, or up-to-date Prisma syntax — Claude often defaults to the version it learned, not what the library ships today. That produces code that fails at runtime in ways that are slow to debug.
How it works: Context7 is an MCP (Model Context Protocol) server that intercepts library-specific queries and fetches current documentation directly from source repositories. When you ask about a specific package, Context7 pulls the live docs and injects them into Claude's context before it responds. Claude codes against what the library actually does today.
Best for: Any stack using fast-moving libraries — Next.js App Router, Supabase, Drizzle ORM, tRPC, ShadCN UI, Vercel AI SDK. If your stack is stable and well-established, the benefit is smaller.
Install:
bashclaude mcp add context7 -- npx -y @upstash/context7-mcp@latest
Restart Claude Code after install.
Usage: Context7 activates automatically when Claude detects a library-specific question. You can also trigger it explicitly:
promptuse context7
Verification: Ask Claude: "Show me the current way to handle authentication in a Next.js App Router project using Supabase." Pre-Context7, expect the old supabase.auth.onAuthStateChange pattern. Post-Context7, you should see the current @supabase/ssr + createServerClient implementation. If you're still getting 2023-era patterns, confirm the MCP server is running:
bashclaude mcp list
Context7 should appear in the list. If missing, re-run the install command and restart.
Plugin 05 — CC-Gemini
Problem it solves: Context window exhaustion on large codebases. Claude's context window is generous — but when you're working across 50+ files, running full-codebase impact analysis, or reviewing an architecture refactor, you hit the ceiling and Claude loses the thread. CC-Gemini routes those large-context tasks to Gemini's 1M+ token window — transparently, without changing your Claude Code workflow.
How it works: CC-Gemini installs as a Claude Code agent plugin. When a task exceeds Claude's efficient context range, the plugin routes it to the Gemini agent instead. Gemini handles the full-codebase pass — architecture mapping, cross-file dependency tracing, large refactor impact reviews — and returns the result back into your Claude Code session. You keep working in Claude Code; the routing is handled for you.
Best for:
- "What would break if I refactor the auth module?" — traces all callers across the entire repo
- "Give me an architecture map of this project" — reads everything at once
- "Summarize schema changes across these config files" — structured data at scale
Not needed for: Single-file edits, short tasks, anything that fits cleanly in Claude's context.
Install:
bashclaude plugin install cc-gemini
Or: Claude Code settings → Plugins → search "CC-Gemini" → Install.
You'll need a Gemini API key. Free tier is available at Google AI Studio. Add the key to your environment:
bashexport GEMINI_API_KEY=your_key_here
Add that line to your ~/.zshrc or ~/.bashrc so it persists across sessions.
Usage: Invoke the Gemini agent explicitly for large-context tasks:
promptUse the gemini-agent to give me an architecture map of this project
Verification: Run that exact prompt in a project with 20+ files. If CC-Gemini is active, Claude Code will route the task to the Gemini agent and you'll see it labeled in the output. If the task runs on Claude directly or errors out, check that GEMINI_API_KEY is set:
bashecho $GEMINI_API_KEY
If blank, add the export line and restart your terminal.
Decision Table — Which Plugin to Install First
Pick based on your biggest friction point right now:
| Bottleneck | Install First | Why |
|---|---|---|
| Hitting rate limits before the build is done | Caveman | ~65% token reduction takes effect immediately — buys more build time per session |
| Re-explaining context every new session | Claude-Mem | One install; context accumulates automatically from that point |
| Claude using wrong or outdated library syntax | Context7 | Stops stale-doc bugs before they cost you debugging time |
| UI output looks like every other AI project | Taste-Skill | Raises the baseline of every component generated from scratch |
| Large codebase — Claude loses the full picture | CC-Gemini | Routes architecture-level tasks to a model built for it |
| Not sure where to start | Caveman → Claude-Mem | Token efficiency + persistent memory are universal gains on any project |
The stack that covers most solo founders: Install Caveman and Claude-Mem first — they compound. Caveman keeps sessions lean; Claude-Mem keeps them continuous. After those two are running, add Context7 if your stack includes any actively developed library, Taste-Skill before your next UI build, and CC-Gemini when your codebase grows past the point where Claude stops seeing the whole picture.
At Hypd, we run all five on every build — the combination is what makes month-long projects feel like week-long ones.
FAQ
Do any of these plugins send my code to external servers?
Caveman and Taste-Skill are local — they modify Claude's behavior through prompt-level instructions with no external calls. Claude-Mem stores memory files on your machine by default; the compression step uses your existing Claude API connection (no third-party service). Context7 fetches documentation from public library repositories — no code leaves your machine. CC-Gemini sends the relevant codebase context to Google's Gemini API when routing a task; review Google AI Studio's data handling terms if that matters for your project.
Do I need all five, or will two cover most cases?
Two cover most cases for most founders. Caveman + Claude-Mem solve the two most universal friction points — rate limits and lost context — and they work on every project regardless of stack. Add Context7 if you build with fast-moving libraries, Taste-Skill if you ship UI, and CC-Gemini if your codebase is large enough that you're losing architectural overview. Start with two, add the others as specific pain points appear.
Will installing these slow down Claude Code or break existing workflows?
None of the five add meaningful latency. Caveman and Taste-Skill are prompt-level — zero overhead. Claude-Mem runs as a background service and injects context at session start, not mid-request. Context7 adds a documentation fetch (typically under one second) on library-specific queries only. CC-Gemini activates only when explicitly invoked or when routing a large-context task — it doesn't touch regular workflow. If anything breaks after install, each plugin can be disabled individually from Claude Code settings without affecting the others.