Open-Source Skills and Plugins that are Actually Worth Using with Claude, Claude Code, ChatGPT, and Codex
There's a lot of noise in this space right now. Repos that are half-finished prompts dressed up as frameworks, plugins that do one cute trick and create three new problems, " systems" that are just a CLAUDE.md with some bolted in.
These are not those.
I keep a set of my own skills at github.com/thebpandey, and if you use LearnStack, you can find them in the LearnStack Toolbox. But this piece is about the community-built projects I've actually installed, tested, and kept running.
They come from five different developers, they solve five genuinely different problems, and they're all free for personal and non-commercial use.
Token Optimizer
github.com/alexgreensh/-optimizer
The thing nobody talks about in AI coding sessions is how fast you burn through without realizing it. Your CLAUDE.md, unused skills, duplicate system prompts, stale memory files: all of it sits in your eating tokens before you type a single word. Then compaction hits and you lose 60-70% of the . That's not a quirk. That's just how these work right now.
Token Optimizer is the only project I've found that treats this as a first-class problem. It covers three waste types most tools ignore entirely: structural waste (the junk eating your context before you start), runtime waste (verbose command output), and behavioral waste (habits like letting the cache expire or running Opus where Haiku would do).
What makes it genuinely useful is the live dashboard. After each session it auto-generates a single HTML file showing per-turn token cost, cache hit rates, quality scores, and exactly which skills and servers fired. Not a vibe, actual receipts. And when compaction approaches, it checkpoints your work and restores what the summary dropped.
It runs fully local. Zero telemetry. No baseline context overhead. Works on Claude Code, Codex, OpenCode, and OpenClaw.
License is PolyForm Noncommercial: free for personal use and small teams. Commercial use requires a license.
/ marketplace add alexgreensh/token-optimizer/plugin install token-optimizer@alexgreensh-token-optimizer
Ponytail
github.com/dietrichgebert/ponytail
AI agents write too much code. That's not a design flaw in the ; it's what happens when a prediction engine has no cost signal on complexity. Ask it to build a date picker and it installs flatpickr, writes a wrapper component, adds a stylesheet, and opens a thread about timezone handling. The built-in `` would have worked fine.
Ponytail gives the agent that cost signal. Before writing any code, it checks a hierarchy: does this need to exist at all? Does stdlib already do it? Is there a native browser/platform feature? Is there an installed dependency? Can this be one line? Only if all of those are no does it write the minimum that works. Every shortcut it takes gets a ponytail: comment naming the upgrade path, so nothing is hidden.
The numbers from the README are real enough to be uncomfortable: across six test tasks, Ponytail produced a seventh of the code of a no-skill agent while passing the same adversarial security probes. 47% fewer tokens. Three times faster. It also ships rules files for Cursor, Windsurf, Cline, Copilot, Aider, and Kiro, so you don't have to stay on Claude Code to use it.
License: MIT.
/plugin marketplace add DietrichGebert/ponytail/plugin install ponytail@ponytail
Beads
github.com/gastownhall/beads
At some point in any serious multi-session project, the markdown TODO list stops working. The agent loses track of what's claimed, what's done, what's blocked. You end up with three different files contradicting each other and a context window full of outdated state.
Beads replaces all of that with a dependency-aware issue graph, backed by Dolt: a version-controlled SQL database with cell-level merge and native branching. Tasks have hash-based IDs to prevent merge collisions across agents and branches. When a 's blockers close, it automatically becomes claimable. Closed tasks decay semantically over time to save context.
The commands are simple enough that an agent can use them without hand-holding. bd ready shows what's available. bd update --claim atomically takes it. bd close marks it done. bd remember "this library has a known bug with X" stores something that persists across sessions.
Native integrations exist for Claude Code, Codex, Cursor, and Factory.ai. You install it once globally; it works across projects.
The project has 25,000+ stars on GitHub. That's not nothing.
License: MIT.
brew install beads# ornpm install -g @beads/bdcd your-project && bd init
BMAD Method
github.com/bmad-code-org/BMAD-METHOD
Most people start a new project by dumping requirements into a chat window and seeing what comes back. That works fine up to a point. Past that point, you get something that kind of works but lacks architecture, has duplicated logic, and will be painful to extend in six months.
BMAD is a structured methodology for AI-driven development. It ships 12+ specialized agent personas (PM, Architect, Developer, UX, and others), 34+ workflows, and a full lifecycle from brainstorm to deployment. The Party Mode feature lets multiple personas argue in the same session, which turns out to be a good way to catch the things a single perspective misses.
The scale-adaptive piece matters. A bug fix gets a light planning pass. An enterprise system gets the full architecture treatment. It adjusts rather than forcing you to manually decide how much process a given task needs.
Web bundles package the planning-phase skills for use inside Gemini Gems or as ChatGPT Custom GPTs, which is a smart move: do the planning work on a flat subscription, then bring the artifacts into a metered IDE where you're paying per token.
It is completely free. No paywalls, no Discord gates, no premium tier.
License: MIT.
npx bmad-method install
ECC
github.com/affaan-m/ECC
ECC is harder to describe in a sentence because it doesn't fit in a category. It's not quite a framework, not quite a plugin pack, not quite a methodology. The README calls it "an agent harness performance system" and that's about as accurate as it gets.
What it actually is: 10+ months of one developer's real production workflows compiled into a single installable system. 67 subagents. 278 skills covering dozens of languages and frameworks. Hooks that fire on tool events. Always-follow rules organized by language. A continuous learning system that pulls patterns from your sessions and turns them into reusable instincts over time.
It works across Claude Code, Codex, Cursor, OpenCode, Gemini, Zed, GitHub Copilot, and others. AgentShield, a security scanner with 102 static analysis rules, is bundled directly. You can run npx ecc-agentshield scan to audit your Claude Code setup for vulnerabilities and injection risks without installing anything else.
One honest note: the scope is large. If you install it and try to use everything at once, it will feel overwhelming. Start with the plugin install and one language rules directory. Add things when you need them.
License: MIT.
/plugin marketplace add https://github.com/affaan-m/ECC/plugin install ecc@ecc
After install, manually copy the rules you actually need into ~/.claude/rules/ecc/. Start with rules/common and one language.
A few things worth saying clearly
All five of these are free for personal and non-commercial work. Token Optimizer's PolyForm license is the one exception worth reading carefully before any commercial use.
Everything here is evolving fast. Install commands change. README instructions get updated. Don't treat anything in this article as the current source of truth: check the repo directly before you install.
The open-source layer around AI coding tools is growing faster than most people realize. Six months from now this list will look different.
