Claude Code out of the box already reads your repo, edits files, and runs your test suite. The problem people run into a few weeks in isn’t that it can’t do something. It’s three quieter things: it re-explores the same codebase every session, it forgets what you told it yesterday, and it writes code from a plan that only exists in its head, so it drifts on anything longer than one sitting.
None of that gets fixed by a bigger model. It gets fixed by plumbing: indexes it can read instead of grepping cold, a place to write down decisions, and a process that makes it commit to a plan before touching a file. That plumbing is mostly not built by Anthropic. It’s a scattered pile of open-source skills, MCP servers, and CLIs that different people built to scratch their own itch, and most of them are genuinely useful. A few of them you should not run with default settings. This is what’s actually in that pile, organized by the problem each thing solves, with the honest caveats left in rather than filed off.
Table of contents
Open Table of contents
1. Stop it from re-reading your repo every session
Every fresh session starts blind. The agent greps around, opens files, and rebuilds a mental map from zero before it writes a line. That exploration is pure token spend that buys you nothing new each time.
Graft
Graft builds a map of your codebase and writes it into your repo as linked markdown files. No embeddings, no vector database, nothing to keep warm. It’s just files the agent opens and greps like any other file, and every query rebuilds against your working tree first, so uncommitted edits still show up. Each teammate runs their own build locally; nothing proprietary gets committed.
npm install -g @nanonets/graft
# or, no global install
npx @nanonets/graft init
graft buildRepo: github.com/trailhq/Graft
Codebase Memory MCP
If you bounce between Claude Code, Cursor, and Codex on the same repo, each one currently rescans it separately. This indexes the codebase into a tree-sitter-based knowledge graph once and exposes it as an MCP server, so “what calls this function” or “give me an architecture summary” is a graph query instead of a full-tree grep. The maintainers cite an independent evaluation across 31 repos showing roughly 10x fewer tokens and 2x fewer tool calls versus plain exploration. Worth checking against your own repo size rather than taking it as a universal number, but the mechanism is sound.
git clone https://github.com/DeusData/codebase-memory-mcp
cd codebase-memory-mcp
# build, then register it as a stdio MCP server in your clientRepo: github.com/DeusData/codebase-memory-mcp
2. Give it a plan before it touches a file
Freeform prompting means the quality of the output tracks the quality of your phrasing that day. Spec-driven tooling forces an explicit written artifact (a spec, then a plan, then tasks) before any code gets generated, so the agent works from something durable instead of re-guessing intent turn by turn.
SpecKit (GitHub, official)
SpecKit is GitHub’s own toolkit for what they call Spec-Driven Development: six or seven purpose-built commands that walk the agent through constitution, specify, plan, tasks, and implement, with optional clarify/analyze/checklist steps in between. Each command produces one concrete file that carries into the next stage, so you get something reviewable and repeatable instead of a chat log. It works across 30-plus agents, not just Claude Code.
specify init my-project --integration claudeInside the project:
/speckit.constitution: set your code-quality and testing standards once/speckit.specify: describe what to build, in plain language/speckit.plan: pin down the stack and technical approach/speckit.tasks→/speckit.implement
Needs uv and Python 3.11+. Codex CLI and Claude Code can run these as skills instead of slash commands with --integration-options="--skills".
Repo: github.com/github/spec-kit
gstack & GSD (Get Shit Done)
Two takes on the same problem: keeping a long, multi-session build from drifting. gstack, from Y Combinator’s Garry Tan, maps 23 specialist roles (eng manager, designer, QA, security, release) onto slash commands following a Think → Plan → Build → Review → Test → Ship loop, aimed at solo builders running a whole product by themselves. GSD is lighter: a meta-prompting layer for scaffolding, phased execution, and roadmap tracking so Claude doesn’t lose the plot across a build that spans several days.
# gstack
git clone --single-branch --depth 1 \
https://github.com/garrytan/gstack.git ~/.claude/skills/gstack
cd ~/.claude/skills/gstack && ./setup
# GSD
/plugin marketplace add gsd-build/get-shit-done
/plugin install get-shit-done3. Make it remember what happened last time
A fresh session has no idea what you decided yesterday, what bug you already fixed, or which approach you already ruled out. This is the gap persistent-memory tools close.
claude-mem
Hooks into the session lifecycle, captures what happened (decisions made, bugs fixed, patterns used), compresses it, and injects the relevant bits back automatically the next time you open the project. Free tier is local SQLite plus vector search at ~/.claude-mem/; nothing leaves your machine unless you opt into the paid cloud-sync tier for following memory across devices.
npx claude-mem install
# restart Claude Code so past-session context loads automaticallyTask Observer
Built by Eoghan Henn. Runs alongside a session and quietly logs the moments where you correct Claude, repeat a workflow, or hit something that worked unusually well. On a scheduled review pass it turns those logged observations into concrete suggested edits to your custom skills. Nothing changes automatically; you approve every diff.
claude install-skill https://github.com/rebelytics/one-skill-to-rule-them-allAdd to CLAUDE.md so it actually fires: “At the start of any task-oriented session, invoke the task-observer skill before beginning work.”
4. Cut the token bill
Every tool call, log dump, and file read is context the model has to hold and pay for. A few tools exist purely to compress that traffic.
Headroom
Sits between the agent and the model, compressing logs, RAG chunks, and file reads. Published benchmarks show 60-95% token savings on tool-heavy traces, and the compression is reversible, so the model can pull the original back on demand. Runs entirely locally.
pip install "headroom-ai[all]"
headroom wrap claudeCaveman
Rewrites Claude’s output to drop throat-clearing while keeping code, commands, and errors exact, for roughly 65% fewer output tokens by the project’s own numbers. A paired local proxy can also compress what gets sent to the model in the other direction; the skill alone is MIT-licensed, the proxy is BSL.
npx skills add JuliusBrussee/caveman
# then: /caveman lite|full|ultra|offRepo: github.com/juliusbrussee/caveman
OmniRoute — read the caveats before installing
OmniRoute sits between Claude Code and 200-plus LLM providers, auto-falling-back when one hits a quota, with a compression pipeline that can meaningfully cut tool-heavy token usage. The idea is solid. The current state of the project is not something to point at production credentials:
- Ships with a hardcoded default auth secret, so anyone on your network can reach the admin panel and pull stored keys until you rotate it.
- Credential encryption at rest is opt-in (
STORAGE_ENCRYPTION_KEY), not default, so keys sit in plaintext otherwise. - An npm release was flagged by Socket.dev for obfuscated code and suspicious install scripts; the maintainer disputes it, but check you’re on a clean, current release.
- It spoofs TLS fingerprints to look like a browser so provider rate limits don’t catch it. That’s against most providers’ terms, and a real ban risk on real accounts.
npm install -g omniroute
omniroute setup-claude5. Give it real hands: MCP servers
MCP is the protocol that lets Claude Code talk to an actual service instead of guessing about it. These five are first-party (built by the company that owns the product, not a community wrapper), which mostly means setup is one command and a login.
Context7 (Upstash)
Models are trained on a snapshot of the internet and will confidently suggest an API that was deprecated eight months ago. Context7 fetches the real current docs for your exact library version and drops them into context before code gets written.
claude mcp add --scope user context7 -- npx -y @upstash/context7-mcp \
--api-key YOUR_API_KEYWorks without a key; get a free one at context7.com/dashboard before you hit rate limits on a busy day.
Chrome DevTools MCP (Google, official)
Turns “the button doesn’t work” into the agent actually opening the page and checking. The official Chrome team server: click, type, fill forms, navigate, screenshot, read console errors with source-mapped stack traces, run Lighthouse.
claude mcp add chrome-devtools -- npx chrome-devtools-mcp@latestThis gives the agent everything in that browser: cookies, logged-in sessions, whatever tab happens to be open. Don’t point it at a profile signed into accounts you don’t want touched.
Vercel MCP (official)
Hosted endpoint, nothing local to run. Ask why a deploy failed or list env vars without opening the dashboard.
claude mcp add --transport http vercel https://mcp.vercel.comSentry MCP (official)
Full stack traces and breadcrumbs, plus Seer, Sentry’s own root-cause agent, triggerable from the same chat.
claude mcp add --transport http sentry https://mcp.sentry.dev/mcpSupabase MCP (official) — real prompt-injection risk attached
List tables, design a schema, run a migration, check RLS policies against your actual project. Authenticated with a personal access token, scoped to one project.
claude mcp add --transport http supabase \
"https://mcp.supabase.com/mcp?project_ref=YOUR_REF" \
--header "Authorization: Bearer YOUR_PAT"Use a read-only or scoped token for daily work. Reach for a service-role key only if you specifically want the agent making schema changes. Supabase’s own docs flag the real risk here: if the agent later reads untrusted data (a support ticket, a form submission), text embedded in it could try to steer the agent into running queries you didn’t ask for. Stage first, point at production only once you trust the workflow.
Every MCP server you connect here is a door into something real: your browser, your database, your deploy pipeline.
6. Give it judgment: Agent Skills
Skills are SKILL.md instruction sets Claude loads automatically when relevant. No external process, just a stronger default way of working. Most ship as plugins: register a marketplace once, then install from it.
- Superpowers: bundles brainstorming, writing-plans, TDD, and git-worktree skills behind a meta-skill that actually forces Claude to use them instead of skipping straight to code.
/plugin marketplace add obra/superpowers-marketplace - Frontend Design (official Anthropic): forces a real aesthetic decision (bold, brutalist, minimal) before any CSS gets written, so you stop getting the same purple-gradient SaaS look by default.
/plugin install frontend-design@claude-plugins-official - Find Skills: a package manager for skills.
npx skills find "git commit messages"returns ranked community skills you can install directly, no manual GitHub hunting. - Skill Creator (official): scaffolds your own
SKILL.mdfiles against Anthropic’s actual spec, for packaging a workflow you keep repeating by hand. - Webapp Testing (official): Claude drives your locally running app, catches broken UI and console errors before you click through it yourself.
- Security Guidance (official): a review pass over your current diff for injection risk and unsafe input handling, useful as a solo dev with no second reviewer.
- MCP Builder (official): best practices for writing your own MCP server, for the day you need Claude talking to a service nobody’s wrapped yet.
- Theme Factory (official): describe a brand in a sentence, get back a coherent palette and type pairing applied consistently across UI, decks, and docs.
The official ones all install from anthropics/skills: /plugin marketplace add anthropics/skills, then /plugin install <name>.
Agency Agents
Instead of writing subagent prompts from scratch, this gives you a maintained roster of 230+ personas (frontend specialist, QA reviewer, growth agent, a “reality checker”) each with a defined workflow and deliverables. It started as a Reddit thread and is now a full open project.
git clone https://github.com/msitarzewski/agency-agents
cp agency-agents/agents/*.md ~/.claude/agents/Repo: github.com/msitarzewski/agency-agents
7. Know what it’s actually costing you
Before installing a third-party usage monitor, two commands already ship inside Claude Code.
/context: visualizes your current context window as a colored grid, right now, no install./usage: session cost and plan limits, also built in.- ccusage: reads your local logs for daily and weekly spend, no API key needed. Run
npx ccusage@latest, ornpx ccusage blocks --livefor a live burn-rate view. - Claude Code Usage Monitor: a fuller terminal dashboard with burn-rate prediction and time-to-limit warnings. Install with
pip install claude-monitor.
If you’re starting from zero
You don’t need all nineteen of these. Most people converge on roughly the same four:
- Superpowers: it plans and tests before it writes code.
- SpecKit or GSD: keeps a multi-day build from drifting.
- Codebase Memory MCP or Graft: stops it from re-reading your repo cold every session.
- Find Skills: makes anything else you need later one search away.
Add the MCP servers as the actual need shows up: Context7 the first time it suggests a deprecated API, Sentry the first time you’re pasting a stack trace by hand, Chrome DevTools the first time you say “check if this actually renders.”
Before installing any third-party skill or plugin, have Claude read the whole thing back to you in plain language first. A skill is just instructions your agent will follow without asking, and a malicious one can quietly exfiltrate files or keys. That one habit catches nearly all of them before they run. Install from the official repo, use scoped tokens over full-access ones wherever an MCP server offers the choice, and remember that every MCP connection is new access, not just a toggle.
Note: Tools in this space move fast. Installation commands and maturity change often, so cross-check the linked repo before running anything on a machine with production access.