# 10 Open-Source Repos That Quietly Make Claude Code 10x Better (Full Guide)
Canonical: https://social-archive.org/yena/nKn1XDnr3m
Original URL: https://x.com/undefinedKi/status/2070852381164630023
Author: Yarchi
Platform: x
## Content
Claude Code is already the most capable coding agent out there. It plans, writes, debugs, ships. But here's the thing almost nobody tells you: if you're running it raw, out of the box, you're using maybe 20% of what it can actually do. The other 80% lives in open-source repos. Skills, harnesses, memory layers, agent teams. Stuff built by people who use Claude Code every single day and got tired of its limits. Plugged in, these turn one agent into something that remembers your codebase, reviews its own work, and ships like a full team. But most of the repos getting hyped right now are noise. Inflated star counts, slick landing pages, and skills that just bloat your context and slow Claude down without doing anything useful. Install the wrong ones and you've made your setup worse, not better. So I went through them. Checked the real GitHub numbers, read the docs, tested the setups, and noted who built each one and why it spread. What's left is 10 repos that are actually worth your time. For each one I'll cover what it is, who it's for, and exactly how to use it. Let's go. # First, for anyone new to this (skip if you know GitHub) GitHub is basically the world's biggest library of open-source code. People build tools and put them there for free, for anyone to download and use. A "repo" (repository) is just one project's folder, the code, the instructions, everything. "Stars" are like likes: the more stars, the more people found it useful. When I say a repo has 200k stars, that's a strong signal it's the real deal. Almost every repo here works the same way with Claude Code. The pattern: 1. Open Claude Code, either in your terminal or in the Claude app (the Code tab). 1. Install it one of two ways. Either copy the one-line install command from the repo's README (its main page), or just paste the repo link into Claude Code and say "install this repo for me." Claude will read the instructions and set it up itself. 1. That's it. The new skill or tool is now available. You call it with a slash command like /review, or just by asking Claude in plain English. No coding required for most of these. If you can copy and paste, you can run them. I'll give the exact command for each one below. # 1. ECC (Everything Claude Code) — affaan-m/ECC ~210,000+ stars Start here, because this is the one that started the whole "configs as a product" wave. If you've used Claude Code, you've seen it: it writes code that breaks, says it "fixed" something it didn't, forgets what you told it five minutes ago, and starts every new chat from zero. That's not you doing it wrong. That's what coding agents do without rules. ECC is the fix. A solo dev, Affaan Mustafa, won an Anthropic hackathon building a full product in 8 hours with just Claude Code, then open-sourced the exact setup he'd spent 10 months refining. It hit 200,000+ stars, one of the most-starred AI repos on GitHub. Once installed, it sits in the background and forces Claude to actually behave: write tests before claiming success, stop faking passing checks, stop committing broken code, and remember your project between sessions. You install it once and every session after that is sharper, with way less hand-holding. Open Claude Code and run: ``` /plugin marketplace add https://github.com/affaan-m/ECC /plugin install ecc@ecc ``` After that you just work normally and most of it runs automatically. But here's where it gets useful day to day. A few commands you'll actually use: > /ecc:plan "add user login with Google" maps out the whole feature before Claude writes a single line, so you don't get 200 lines of the wrong thing. > npx ecc-agentshield scan checks your project for security holes, then npx ecc-agentshield scan --fix patches the safe ones automatically. > /analyze-repo drops Claude into an unfamiliar codebase and gives you a clean map of how it all fits together, perfect when you inherit someone else's project. > /instinct-status shows you what ECC has learned from your past sessions. The longer you use it, the more it adapts to how you build. The rest, like enforcing tests, saving context, and blocking broken commits, just happens once it's installed. # 2. GStack — garrytan/gstack 115,000+ stars This one's from Garry Tan, the CEO of Y Combinator, the startup accelerator behind Coinbase, Airbnb, and Stripe. He's been building products for 20 years, and he open-sourced the exact Claude Code setup he now uses to ship more code than at any point in his career, part-time, while running YC. Where ECC keeps Claude disciplined, GStack gives it a whole team. It turns one agent into a virtual startup: a CEO that pushes back on your idea before you build the wrong thing, an engineering manager that plans the architecture, a designer that catches ugly AI output, a reviewer that hunts production bugs, a QA lead that opens a real browser and clicks through your app, and a release engineer that ships it. You drive it like a CEO, checking the big decisions and letting the rest run. For solo builders and small teams who want the rigor of a real engineering org without hiring one. If you're shipping actual products, not just experimenting, this is the workflow. Install by opening Claude Code and running: ``` git clone --single-branch --depth 1 https://github.com/garrytan/gstack.git ~/.claude/skills/gstack && cd ~/.claude/skills/gstack && ./setup ``` Then you run your work through a sprint, one command at a time. Here are a few of the commands you'll reach for most (there are 23 in total) > /office-hours asks you six sharp questions to kill bad ideas early. > /plan-eng-review designs the architecture before any code. > /review scans what Claude wrote for real production bugs and fixes them. > /qa opens an actual browser and tests your app like a user would, then writes regression tests so the bug never comes back. > /ship runs the release with a full test audit. Each step feeds the next, so you go from idea to shipped without the usual mess. # 3. Matt Pocock skills — mattpocock/skills 145,000+ stars Matt Pocock is a well-known TypeScript educator (he built Total TypeScript and teaches ~60,000 devs through his newsletter). He took the exact skills he uses every day for real engineering and published them. The repo crossed 145,000 stars almost entirely by word of mouth, developer telling developer, which tells you it hit a real nerve. His whole pitch is in the tagline: "skills for real engineers, not vibe coding." Where GStack gives Claude a team, these skills give it discipline. They don't make the model smarter, they make it less reckless. The big one is that Claude loves to build the wrong thing because it assumed what you meant. His skills force it to stop guessing, ask sharp questions first, write tests properly, and keep your code from rotting into an unmaintainable mess as the agent moves fast. For anyone who's graduated from "make me a quick app" to actually maintaining real software, especially in TypeScript and JavaScript. If you've watched Claude confidently build something you didn't ask for, this is the cure. Install by opening Claude Code and running: ``` npx skills@latest add mattpocock/skills ``` Pick the skills you want when prompted, and make sure you include /setup-matt-pocock-skills, which configures everything for your project. Then you call them when you need them. A few of the most useful (there are around 17): > /grill-me interrogates you about what you actually want before a single line gets written, so you don't end up with the wrong feature. > /tdd forces proper test-first development instead of Claude claiming code works without checking. > /improve-codebase-architecture rescues a messy project that's become hard to change, and Matt recommends running it every few days to stop the rot. > /diagnosing-bugs runs a disciplined debugging loop instead of random guessing. One note: these lean toward TypeScript and JavaScript conventions. If you work in a very different stack, you'll still get value, but some skills will fit better than others. # 4. Graphify — safishamsi/graphify 70,000+ stars Remember the problem from earlier: Claude Code forgets everything between sessions and re-reads your whole project every time to figure out what's going on. On a mid-size codebase that burns tens of thousands of tokens before you've even asked a question. Every session. That's slow and it's expensive. graphify fixes exactly that. It turns any folder, code, docs, even PDFs and images, into a queryable knowledge graph: a structured map of how everything connects. Instead of re-reading every file, Claude just queries the map and gets the answer. On the project's own benchmark that meant roughly 1,700 tokens per query instead of 123,000, about a 71x cut. It built one of the fastest-growing repos of the year, going viral 48 hours after Andrej Karpathy (OpenAI co-founder) posted his own knowledge-base workflow. (If you saw our breakdown of Karpathy's second-brain setup, this is the tool that does the heavy lifting.) For anyone working on a real codebase who's tired of slow, pricey sessions, or who wants Claude to actually understand how their project fits together instead of guessing file by file. Install by running this in your terminal first: ``` uv tool install graphifyy ``` (Yeah, with two y's, that's the official one). Then register it with your agent: ``` graphify install ``` Then in Claude Code, run /graphify . once to build the map of your project. First run is slower, after that it just updates what changed. From then on, ask normally: > /graphify query "how does login work?" and Claude answers from the graph instead of reading every file. > /graphify --update refreshes it when your docs change. You can even commit the map to git so your whole team's Claude starts already knowing the codebase. Note: the 71x figure is a best case on a specific project. Your savings depend on how big your codebase is. On small projects, plain Claude with search is sometimes just as cheap. Where graphify really pays off is on large, complex codebases run many times a day. # 5. GBrain — garrytan/gbrain 24,000+ stars This is the second one from Garry Tan, the YC CEO, and it's the deep version of the memory problem. Where graphify gives Claude a memory of your code, GBrain gives it a memory of your whole working life: people, companies, meetings, emails, decisions, ideas. It's not a side project either. It's the actual production brain Garry runs his business on, holding 146,000+ pages, 24,000+ people, and 5,000+ companies, with dozens of automated jobs updating it while he sleeps. The magic is that it doesn't just hand you matching pages, it synthesizes an answer. Ask "what do I need to know before my meeting with Alice tomorrow?" and instead of ten links, you get written prose: what she works on, when you last spoke, what's still open between you, all cited. It builds a self-wiring graph of who knows whom and who did what, so it surfaces connections plain search would miss. For founders, investors, operators, and anyone whose work runs on relationships and context, not just code. If you've ever walked into a meeting blanking on someone you've emailed 50 times, this is built for exactly that. Wire it into Claude Code as a memory layer. The fastest way to try it is the local version, no accounts, no server, ready in about 30 seconds. In your terminal: ``` git clone https://github.com/garrytan/gbrain.git && cd gbrain bun install && bun link gbrain init ``` That sets up a local brain on your machine. Now feed it some notes and ask it something: ``` gbrain import ~/notes/ gbrain query "what themes show up across my notes?" ``` To plug it into Claude Code so your agent can use it directly, run: ``` claude mcp add gbrain -- gbrain serve ``` From there you just talk to it in plain English. Point it at a folder of notes, meeting transcripts, or emails, then ask "who works at Acme AI?" or "what did Bob invest in this quarter?" and it answers from everything it's ingested, with citations. Later, you can connect Gmail, Google Calendar, and meeting transcripts so it keeps filling itself in automatically. One real heads up: that local version above is the easy on-ramp. The full system Garry runs, the one with auto-updating jobs and a team brain, means setting up a real database (Supabase), more API keys, and background jobs, plus real monthly cost if you go all in. Garry himself jokes in the docs that the full setup is "too complicated for a normal person." So start local, get a feel for it, and only graduate to the full stack if you fall in love. Two install gotchas the project itself flags: don't use bun install -g github:garrytan/gbrain and don't use npm install -g gbrain (a fake package is squatting that name). Use the git clone path above. # 6. SkillSpector — NVIDIA/SkillSpector 5,500+ stars Every skill you add to Claude Code runs with real access to your files, your network, and your environment variables, and there's basically no security gate between "install" and "it's running on your machine." A study of 42,447 real-world skills found that 26% of them contained a vulnerability and 5% showed likely malicious intent. That's not a rounding error. SkillSpector, built and open-sourced by NVIDIA, is the bouncer at the door. Point it at any skill before you install it and it scans for the dangerous stuff: hidden instructions, prompt injection, data exfiltration, sketchy code, and skills that quietly ask for way more access than they need. You get a 0-to-100 safety score and a clear "should I install this or not." For literally everyone installing skills, which after this thread is you. Especially worth it before you add anything from a random GitHub repo or marketplace you don't recognize. Install it by opening Claude Code and just asking: ``` Install SkillSpector from https://github.com/NVIDIA/skillspector and use it to scan this skill before I add it ``` Claude runs it for you. Under the hood it's a command-line tool, but you don't need to touch the terminal yourself, Claude Code handles the commands. Then any time you're about to add a new skill, have Claude scan it first. Point it at a GitHub repo, a folder, or a single file, and it hands back a risk report in seconds: a 0-to-100 score, what it found, and whether to trust it. Make this a habit, scan first, install second. It's the cheapest insurance on this whole list, and the one most people skip until something goes wrong. If you'd rather run it yourself in the terminal, the manual command is: ``` uv tool install git+https://github.com/NVIDIA/skillspector.git skillspector scan https://github.com/some-author/some-skill ``` # 7. Cybersecurity Skills — mukul975/Anthropic-Cybersecurity-Skills 4,000+ stars Staying on security, but flipping it around. The last one checked if skills are safe. This one makes Claude itself a security expert. It's a library of 817 structured cybersecurity skills, everything from malware analysis and threat hunting to cloud breaches and incident response, each one a step-by-step playbook mapped to the real frameworks the industry uses (MITRE ATT&CK, NIST, and more). The idea is simple: a junior security analyst knows which tool to run on a suspicious file, which rules catch a specific attack, how to scope a breach across cloud providers. Your AI agent doesn't, until you give it these skills. Once installed, you can point Claude at a security problem and it stops guessing and starts following expert procedure. For developers who want to harden their own apps, security hobbyists, and anyone curious about defense. You don't need to be a security pro, the skills carry the expertise, you just point Claude at the problem. Install by opening Claude Code and running: ``` npx skills add mukul975/Anthropic-Cybersecurity-Skills ``` Then ask Claude security questions in plain English and it pulls the right playbook. "Review my web app for the OWASP Top 10 vulnerabilities" makes it audit your code against the standard list of common holes. "Walk me through investigating this suspicious login activity" gives you a real incident-response procedure instead of vague advice. Tip: don't load all 817 at once, install the domain you actually need (like cloud security or code scanning) so you don't bloat Claude's context. # 8. OpenMontage — calesthio/OpenMontage 18,000+ stars Time to step outside of code, because Claude Code isn't only for software. OpenMontage turns your AI agent into a full video production studio. You describe the video you want in plain language, and the agent does the whole thing: researches the topic, writes the script, generates or finds the visuals, adds narration and music, edits the timeline, and renders a finished MP4. It hit #1 on GitHub trending recently for good reason. Depending on the mode, that's either AI-generated clips (if you plug in models like Veo or Runway), real archival footage stitched into a timeline, or generated images animated into a polished edit. It has 12 different production pipelines: cinematic trailers, animated explainers, talking-head spokesperson videos, real-footage documentaries (pulling actual clips from open archives like NASA and Archive org), and more. You can even hand it a YouTube video you love and say "make me something like this but about my topic," and it builds a plan from the reference. For creators, marketers, educators, and anyone who wants video without learning an editor or paying for five separate AI subscriptions. By the project's own examples, a 60-second narrated animated short can cost just over a dollar in API credits, and there's a fully free path using local models and free stock footage. Before installing, you'll need a few things on your machine: Python 3.10+, Node.js 18+, and FFmpeg (the video tool). Then open Claude Code and run: ``` git clone https://github.com/calesthio/OpenMontage.git cd OpenMontage make setup ``` Once it's set up, open the project in Claude Code and describe what you want in plain language: > Make a 60-second animated explainer about how neural networks learn Or for the real-footage documentary path: > Make a 75-second documentary montage about city life in the rain. Use real footage only, no narration. The agent researches your topic, writes and narrates the script, finds royalty-free music, burns in subtitles, and renders the final video. It shows you a plan and a cost estimate before spending anything, and runs its own quality checks before handing you the finished cut. You can also paste a YouTube or TikTok link and say "make one like this but about my topic." Heads up: the free path gives you a polished animated video (think moving visuals with narration and captions), not Hollywood-grade filmed footage. For AI-generated motion clips you'll need to plug in paid models. Either way, this is the most resource-heavy one to set up, so start with a short 30-to-60-second clip to get a feel for it before attempting anything big. # 9. DeerFlow — bytedance/deer-flow 74,000+ stars This one's from ByteDance, the company behind TikTok, and it's the heaviest hitter on this list. DeerFlow is built for the long, complex tasks that would normally take you hours or days. You hand it something big like "research the top 10 AI startups of 2026 and build me a presentation," and instead of choking on it, a lead agent breaks the job into pieces, spins up a team of sub-agents to work in parallel (one scrapes data, another does analysis, another builds charts), and stitches it all back together at the end. The difference from a normal chatbot is that it actually does the work in a real, sandboxed environment, it doesn't just describe what it would do. It runs code, builds files, generates dashboards and slide decks, and produces finished deliverables. It has its own memory, its own filesystem, and it can run for a long time without losing the thread. When it launched, it shot to #1 on GitHub trending in 24 hours. For people with genuinely big, multi-step jobs: deep research reports, data pipelines, building dashboards, automating whole content workflows. This is overkill for "write me a function," it shines when the task is large enough that you'd want to delegate it and walk away. Install by opening Claude Code and running: ``` git clone https://github.com/bytedance/deer-flow.git cd deer-flow make setup ``` That launches a setup wizard for your API keys and preferences. Then start it (Docker is the recommended way): ``` make docker-start ``` It opens a full agent interface in your browser. You can even connect it to Telegram or Slack and fire off tasks from your phone. Two honest notes. First, it's model-agnostic (works with Claude, GPT, Gemini, and others), but it's the most infrastructure-heavy setup here, it really wants Docker and some real machine resources, so it's aimed at more technical users. Second, since it's a ByteDance project that runs code and fetches data, some people and companies will want to review the security and country-of-origin context before deploying it for serious work. The code is open (MIT) and auditable, just go in informed. # 10. OpenClaw — openclaw/openclaw 250,000+ stars Saving the biggest for last. OpenClaw is the fastest-growing open-source project in GitHub history. An Austrian developer named Peter Steinberger built the first version in about an hour as a personal experiment, and within months it blew past React to become the most-starred piece of actual software on all of GitHub. OpenAI hired him off the back of it. Everything else on this list lives inside your coding tool. OpenClaw breaks the AI agent out of the terminal and puts it in the apps you already use: WhatsApp, Telegram, Slack, Discord, iMessage, and dozens more. It runs locally on your own machine, around the clock, so you can text your AI assistant from your phone like a friend and it actually does things: manages your calendar, handles email, runs research, controls tools, all on your own devices with your own data. This is the "where it's all heading" pick: not a coding helper, but a personal agent that lives in your life. For people who want a true 24/7 personal assistant they fully own and control, not a cloud service that logs everything you type. If you've ever wished you could just message an AI to handle stuff while you're away from your computer, this is that. Install it in your terminal: ``` npm install -g openclaw@latest openclaw onboard --install-daemon ``` The onboard wizard walks you through connecting your messaging apps and your AI model (bring your own Claude or OpenAI key). Once it's running, you just message it on whatever app you connected, "summarize my unread emails and draft replies," "remind me to call the dentist at 3pm," and it works in the background. # The Bottom Line That's the 10. Quick recap before you go install everything at once: don't. Start with one. If you write code, ECC is the obvious first move, it fixes the most pain for the least effort. If your problem is Claude forgetting things, go graphify. If you just want to see something cool, OpenMontage makes a video in minutes. Pick the one that matches your actual problem, install it, use it for a week. Then come back for the next. And whatever you add, scan it first with SkillSpector. Popularity isn't safety. If this was useful, head to my profile and follow. I write about AI, Claude, and systems that actually run. ## Ciao, ## [@undefinedKi](https://x.com/@undefinedKi)