Skill libraries, prompt packs, and add-ons for coding agents like Claude Code, Codex, and OpenCode.
Ranked by Discovery Score — our 0-100 composite of adoption, maintenance, community, and license health. How scoring works.
By Erik Loyd, SaaS CEO and former COO/CFO of an AWS Premier Partner.
gstack is Garry Tan's (YC CEO) Claude Code workflow as a public repo. It ships 23 specialized agents that act like a virtual engineering team, plus slash commands like /office-hours, /review, and /ship that drive end-to-end product work from one terminal. The agents play roles: CEO, designer, engineer manager, QA lead, and more. The idea is that a solo dev orchestrates the team through commands instead of doing every job in series. TypeScript core with some Go for the parts that need speed. Everything lives in .claude/, nothing touches your PATH, and a persistent Chromium browser daemon handles visual testing and QA loops. MIT licensed. Solo devs and tiny teams are the target. If you're already shipping by yourself with Claude Code, this is a real upgrade. Bigger teams will trip over the opinionated roles, since you already have a real designer and QA lead and don't need an agent pretending to be one. The catch: this is one founder's workflow turned into a kit. If your style doesn't match Garry's, you'll fight the agents instead of using them. It's also Claude Code only. No Cursor, no Codex, no swap-in for other harnesses.
Free. You pay only for your existing Claude Code subscription and the tokens the agents burn.
Fully open source under MIT. No paid tier, no hosted version. You clone the repo into your project's .claude directory and use it with Claude Code. Cost is whatever you already pay for your Claude Code subscription plus the API tokens the agents burn through during a session.
Everything Claude Code (ECC) is a plugin you install through the Claude Code marketplace that bundles 63 agents, 249 skills, 79 commands, hooks, MCP server configs, and security enforcement scripts into one harness. The pitch is: stop hand-rolling your CLAUDE.md and skills, install this and get a curated set that actually works. It's MIT licensed and works across Claude Code, Cursor, OpenCode, and Codex, not just Claude. The agents cover the usual suspects (code review, security analysis, planning, language-specific reviewers) and the skills span TDD, video editing, and dozens of niche workflows. Hooks auto-execute on editor events. The security scanning piece tries to catch prompt injection and rule violations before they hit your codebase. Solo devs and small teams using AI coding agents get the biggest lift here. Pulling in 63 agents you didn't ask for is overkill, but cherry-picking the ones that match your workflow is the real value. Large teams will probably want to fork it and trim aggressively. The catch: 249 skills is a lot of surface area to audit. You're trusting someone else's prompt engineering to run inside your editor. Read the security-relevant pieces before you turn the hooks on, and treat this as a starting template, not gospel.
Free and open source. You pay for the LLM API or subscription behind whichever harness you run it on.
Fully open source under MIT. No paid tier for the plugin itself. The ecc.tools site may host extras, but the GitHub repo has the full bundle. Your cost is the LLM API or subscription you already pay for whatever harness you run this in.
Graphify reads your entire codebase, docs, PDFs, and even screenshots, then builds a knowledge graph you can actually navigate. It parses 19 languages via tree-sitter for code and uses an LLM for everything else. The result is an interactive HTML visualization showing how your architecture, concepts, and files connect. The first extraction pass costs real API tokens (Claude or GPT), proportional to your corpus size. After that, incremental updates via SHA256 caching mean re-runs only process changed files. The 71x token compression claim is real for subsequent queries, not the initial scan. Runs as a /graphify slash command inside Claude Code, Codex, or OpenCode. For developers onboarding to large or unfamiliar codebases: this is genuinely useful. Architecture reviews, cross-referencing code with design docs, understanding how a monorepo fits together. Exports to Neo4j, Obsidian vaults, or standalone wikis. The catch: it is a plugin, not a standalone tool. You need Claude Code or a compatible AI assistant as the runtime. Quality of inferred relationships depends on the underlying LLM, and the initial scan of a large repo is not cheap.
Tool is free. LLM API costs for extraction depend on corpus size.
### Free Tier Fully free under MIT. No paid tier or hosted service. ### Self-Hosted pip install, then run as a slash command. No server or database needed. All local. ### Paid None for the tool. You pay for LLM API tokens during extraction passes.
Career-Ops turns your AI coding CLI into a full job search command center. Paste a job URL and get back a structured report broken into blocks A through H, with a single 1 to 5 score reached by holistic judgement across five dimensions. It generates tailored, ATS-optimized PDF resumes per application. One developer used it to evaluate 740+ offers and land a Head of Applied AI role. The system gets smarter over time. It builds an interview story bank in STAR format, ships a scanner preloaded with 100+ companies and 45+ search queries, and can batch-evaluate offers in parallel using sub-agents. The dashboard is a Go TUI built on Bubble Tea, so you browse the entire pipeline from the terminal, and an experimental web UI is available as an opt-in alpha. Running it needs Node.js and Playwright for the PDF generation and portal scanning. Solo job seekers running any AI coding CLI: this is a force multiplier. It used to be Claude Code only, and now it also works with Gemini, OpenCode, Qwen, Grok, Codex, and Kimi, several of which have free tiers. It does not replace your judgment, it structures it. The human in the loop design means the AI evaluates and you decide. The catch: the tool is free, but it leans on an AI CLI underneath, so your real cost depends on which provider you pick and how hard you run it. The preloaded company list skews heavily toward AI and tech companies. And the first evaluations are rough until you feed it enough context about yourself.
Free and open source (MIT). Runs on any AI coding CLI, including free options like Gemini CLI.
### Free Tier MIT license, no paid features. All functionality is in the open source repo. ### Self-Hosted Clone, npm install, and install Playwright for PDF generation and portal scanning. All data is stored locally in markdown and YAML files. ### Paid None for the tool itself. It runs on top of an AI coding CLI: some are paid (Claude Code), others have free options (Gemini CLI, Qwen), so the real cost is whatever provider you choose.
This is a library of more than 2,000 reusable SKILL.md playbooks for coding agents. Skills are structured prompts that teach an agent a specific job (write tests, harden a web app, run a data pipeline), and the project installs them into Claude Code, Cursor, Codex, Gemini CLI, Kiro, OpenCode and others. MIT for the code, CC BY 4.0 for the content unless an upstream notice says otherwise, free.
You install with npx agentic-awesome-skills plus a tool flag like --claude, and the installer now makes you choose: named skills, a risk, category or tag filter, or explicit consent for the whole catalog. The project itself says to start with a focused plugin instead. Newer releases add AAS Core, an optional local CLI and MCP server that lets an agent search the catalog and validate the skills it picks.
For anyone building an agent workflow, this is a fast way to skip writing every skill from scratch. Solo developers and teams get the same value, since skills are just files you version alongside your project.
The catch is curation. Thousands of community skills mean variable quality and overlap, and an installed skill is a prompt your agent will follow. The catalog labels some skills critical or offensive, and an audit command flags network, credential and destructive signals, but the project calls that a review aid, not a safety certificate. Read the ones you install.
Free and open source. The real cost is the time it takes to vet the skills you install.
**Free tier:** MIT code and CC BY 4.0 content, where more specific upstream notices can override: 2,000+ skills, the installer CLI, focused plugins, bundles, risk labels, an audit command, and the AAS Core preview. Funding comes from optional GitHub Sponsors and Buy Me a Coffee. **Self-hosted:** Nothing you have to run. Skills install as files into your agent's config directory through `npx`. AAS Core's `aas` CLI and MCP server run locally if you opt in; its apply and recovery features are still experimental. **Paid:** None.
jev-ultrafast is Browser Use's speed demo for a new kind of model. Normal browser agents ask a chat model to write out its next step. This one hands Jev, a decision model from TypeSafe AI that returns typed choices instead of text, a numbered list of page elements and gets back which one to click. A small text model only writes the words that need typing. The README's showcase is a Zurich to London search on Google Flights in about seven seconds. MIT licensed. It is source code, not a product: uv sync, a local Chrome with remote debugging on, and two paid keys. One is a TypeSafe key for Jev, which bills $0.042 per million input tokens with free output and is waitlisted right now. The other is an OpenRouter key for the text model. No releases, version 0.1.0, and the README calls it an MVP. Solo builders curious about decision models: worth an evening once you clear the waitlist. Teams that need browser automation today should use the same company's main browser-use library, or Skyvern. The catch: the benchmark is three repeats of one task on one browser profile, and the README says so. Shadow DOM, iframes, canvas, uploads, and pop-up tabs are out of scope. And the whole thing depends on a closed API you cannot self-host.
Free MIT code that cannot run without two paid API keys, one of them for a closed, waitlisted model.
**Free:** The MIT source code: a Python browser agent that uses Jev for element decisions and a small text model for typed input. **Self-hosted:** Runs on your machine against a local Chrome. There is no way to self-host the model it depends on, because Jev is a closed API. **Paid:** Nothing to Browser Use. Every run makes paid API calls to two outside services: TypeSafe AI's Jev at $0.042 per million input tokens (output tokens free, access currently waitlisted) and an OpenRouter-hosted text model. The repo also promotes a waitlist for Browser Use Cloud.
This is a curated collection of subagents for OpenAI's Codex CLI, now past 170 entries across more than a dozen categories. Picture an app store of pre-built specialists: each subagent is a config file tuned for one job, testing, documentation, security review, database migration, and dozens more. You don't build these yourself. You browse the list, grab the ones that fit your workflow, and drop them into your Codex agents directory. They use Codex's native TOML format with Codex-specific fields like reasoning effort and sandbox mode. Codex does not spawn them automatically, you delegate to them explicitly. The collection is free. You pay for Codex usage through your OpenAI account. It is community-maintained and still growing, so the catalog keeps expanding. The catch: this is a curated list, not a framework. Quality varies across the entries. Some are polished, some are experiments. And it is Codex-only. It does not work with Claude Code, Cursor, or other AI coding tools, so the value evaporates the moment you switch assistants.
Free collection. You pay for Codex usage.
Fully open source under MIT. It's a curated list of subagent configurations. No software to install, no hosting needed. Browse, copy, use. The cost is whatever Codex charges for running the subagents.
Diagram-design is a Claude Code skill for editorial-quality diagrams. Architecture sketches, flowcharts, sequence diagrams, quadrants, pyramids. 13 types total, all rendered as self-contained HTML and SVG with no JavaScript or build step. The output is opinionated: low density, restrained color, accent used sparingly on the one or two things that matter. It looks like something a design team made, not generic AI output. Install is clone or plugin, then tell Claude to onboard it to your website and it pulls your brand palette and typography from your homepage. After that every diagram uses your colors. The skill activates automatically when you ask for a diagram. Solo writers and technical bloggers: install it. Small teams with a brand style guide: install it team-wide and onboard to your site. Large teams with a design system: the editorial constraints may conflict with your existing design language, evaluate first. The catch: the plugin route puts the skill in a cache that updates overwrite, so style-guide customizations get wiped unless you clone the repo and symlink. And the opinionated style is the whole pitch. If you want Mermaid-style diagrams, this is the wrong tool.
Free. Requires Claude Code to use.
**Free and open source.** Clone the repo or install via Claude Code's plugin marketplace. No paid tier, no cloud service, no premium version. The onboarding flow reads your website with Claude and writes the color tokens to a local file. All inference runs in your Claude Code session using your existing plan. No third-party API keys required beyond what Claude Code already needs. If you are already paying for Claude Code, there is no additional cost. If you are not, this isn't the reason to start.
OpenViking is a context database built specifically for AI agents. Instead of the usual pile of vector embeddings, it organizes an agent's memory, retrieved documents, and skills the way a filesystem organizes files: directories you can navigate, tag, and search recursively. It is open source under AGPL-3.0. Setup is heavier than a typical pip install. You will need Python 3.10+, a Rust toolchain for building the RAGFS component, and a C/C++ compiler for the core extensions, on top of wiring up a vision-language model and an embedding model (Volcengine Doubao, OpenAI, or others) before it does anything useful. Once running, it compresses conversation history automatically and shows you the retrieval path it took to answer a query, so debugging why an agent recalled the wrong thing is actually possible. There is a hosted demo, OpenViking Studio, if you want to try the retrieval and memory features before committing to the build. Solo devs experimenting with agent memory: worth the setup time if you are hitting the limits of flat vector search. Teams building production agents: the tiered loading, it only pulls in the context tier it actually needs, is the real selling point for cutting token costs at scale. It is AGPL-3.0, not MIT or Apache. If you build a hosted product on top of OpenViking and offer it as a network service, the license requires you to open source your modifications too. That is a real constraint for anyone planning to build a commercial product on this, not just an internal tool.
Completely free and open source, but AGPL-3.0 comes with real strings attached if you are building a commercial product on top of it.
**Free (only option):** OpenViking is fully open source under AGPL-3.0. No paid tier, no hosted managed offering beyond a browser demo. **Self-hosted:** Requires Python 3.10+, a Rust toolchain (Cargo) to build the RAGFS component, and a C/C++ compiler for core extensions. You also need to bring your own vision-language model and embedding model, so add whatever those API calls cost. **Paid:** None currently. The AGPL-3.0 license means if you build a commercial hosted product on top of it, you are required to open source your changes.
Cloudflare's Security Audit Skill turns a coding agent into a vulnerability auditor. A skill is a module you add to an AI coding agent to give it a specific job. This one runs a six-phase audit: it maps your app, sends parallel agents to attack from different angles, then has separate agents try to disprove each finding before it gets reported. The philosophy is blunt, only report what you can actually exploit, with a concrete attack scenario, not a checklist of maybes. MIT licensed and free. There is no service to run. You install it into your agent with one command, npx skills add, and ask it to audit a codebase. The only real dependency is a coding agent that supports tool use and parallel sub-agents, plus Node for schema validation. The cost you do pay is model tokens, since the multi-phase, multi-agent design burns through a lot of them on a real codebase. The independent verification pass exists to cut false positives, which is the usual failure mode of AI security scanners. For solo developers and small teams without a security budget, this is a strong first pass and it is free. Larger teams should treat it as one input, not a replacement for a real pentest or a human reviewer. The catch: it is only as good as the agent running it and the tokens you feed it. It finds plausible issues and verifies them, but it does not replace someone who actually understands your threat model.
Free and MIT licensed. Your real cost is the model tokens the multi-agent audit consumes.
**Free:** MIT licensed and free. Install it into your coding agent with one command (npx skills add) and run as many audits as you want. No license fee from Cloudflare. **Self-hosted:** It runs inside your own coding agent, so there is no separate service to operate. The dependencies are a coding agent that supports tool use and parallel sub-agents, plus Node for schema validation. The real cost is model tokens: the six-phase, multi-agent design consumes a lot of them on a real codebase, so your LLM bill is the thing to watch. **Paid:** No paid tier for the skill itself. Your spend is whatever your AI model provider charges for the tokens it burns.
Prompt Master writes the prompts for you. It's a Claude Code skill that generates accurate, context-aware prompts for any AI tool, optimized so you waste fewer tokens and get better output on the first try. The value proposition is simple: instead of trial-and-error with different prompt phrasings, you describe what you want and Prompt Master generates the prompt that actually works. It retains full context and memory across your session, so each prompt builds on what came before. MIT licensed. The catch: this is a skill that writes prompts for other AI tools, so you're adding an extra LLM call before every interaction. If your prompts are already working fine, this is overhead. And 'accurate prompts' is a bold claim. Prompt engineering is still more art than science, and what works for one model may not work for another.
Free. Adds marginal API cost per prompt generation.
Fully open source under MIT. No paid tier, no hosted version. Install as a Claude Code skill. The only cost is the additional Claude API usage for generating prompts, essentially paying for an extra LLM call before each task.
Watermarks-remover strips AI provenance marks from text and files: invisible Unicode watermarks (zero-width characters, bidi marks) from text, and C2PA manifests, EXIF, and XMP metadata from images, PDFs, and Office documents. It ships as an agent skill plus standalone Python scripts, MIT licensed, stdlib-only at the core. The legitimate use is real: invisible Unicode breaks diffs, search, and paste, and metadata on your own files is yours to remove. The honest part is what it admits it can't do. Deterministic removal covers Unicode and file metadata; statistical watermarks baked into AI text get best-effort rewriting that degrades the prose, and the project says so. Its own ethics doc rules out academic fraud and disclosure-dodging, and states plainly that a removed mark doesn't mean the content was never AI-assisted. Use it for hygiene on files you own. For pure image metadata work, exiftool and mat2 are the incumbents, and this wraps rather than replaces them. The catch: it cannot verify its own success against the strongest watermarks, and if your reason for reaching for it is a disclosure rule, the tool's own documentation tells you not to. It's also brand new, so treat the polish as unproven.
Completely free and open source. The optional SynthID scorer's upstream carries a non-commercial research license.
**Free:** Everything. MIT, Python stdlib for the core scripts. Optional exiftool and c2patool are auto-detected when present. **Optional heavy piece:** A SynthID pixel scorer (detection only, never removal) pulls a ~220MB codebook from an upstream project under a non-commercial research license. That upstream license is a real constraint for business use of that one feature. **The trade:** Free and local, but best-effort by design against statistical watermarks.
img2threejs takes a reference image and rebuilds the object in it as procedural Three.js code, using primitives and shaders instead of a downloaded mesh. It is an agent skill, not a library: you install it into Claude Code, Codex, or OpenCode and the agent runs the pipeline. Apache 2.0 since July 2026, when it moved off MIT. The design is the interesting part. Deterministic Python scripts handle validation, quality gates, and code generation using only the standard library, while the model's tokens go to the visual judgment steps: look at the image, assess it, review the render. Version 2.0 turned it into a plugin system with an img2 installer, official plugins for characters and Counter-Strike 2 weapons, and a GLB export path. Web developers who need 3D objects and would rather not model them or license assets are the audience, mostly solo and small teams. Subjects are classified as object, character, or hybrid, and characters route through an anatomy-aware track. The catch: it is strongest on hard-surface objects, and the project says so. Characters come out as stylized reconstructions, not photoreal likeness, even with the new opt-in projection path. It is also token-hungry by the README's own admission, estimating roughly 80k to 180k tokens per object. It will tell you when an image cannot reach the fidelity you asked for.
Free and Apache 2.0. You pay for agent tokens, and the project estimates 80k to 180k of them per object.
**Free:** Everything. Apache 2.0 (relicensed from MIT in July 2026). There is no hosted version and no paid tier, because it is a skill that runs inside an agent you already pay for. The project is funded by sponsors and donations. **Self-hosted:** Nothing to host. The core needs Python 3.10 or later and only the standard library. The plugin installer runs through npx, and optional components (SAM2 masks, depth estimation, the GLB pipeline) bring their own dependencies. **Paid:** None. Your spend is agent tokens. The project's own engineering estimate is roughly 80k to 180k tokens for one object and 150k to 350k for a character.
claude-obsidian turns an Obsidian vault into something a coding agent can actually work in. Drop a source in and the agent reads it, pulls out entities and concepts, writes cross-referenced pages, and keeps the links honest. Your vault stays a plain directory of Markdown files rather than a proprietary database, which is what matters if you expect to still have these notes in five years. MIT licensed. Now at v2.1.0 with 15 skills spanning ingestion, querying, wiki building, linting, research, and Canvas generation. Operations are transactional with rollback and conflict detection, which sounds dull until an agent half-finishes a bulk edit across 200 notes. Needs Python 3.11 or newer plus bash. Obsidian itself is optional, since the output is just Markdown. It no longer assumes Claude Code. Cursor, Windsurf, Codex, OpenCode, and Gemini all work, and you choose a methodology up front: generic, LYT, PARA, or Zettelkasten. Solo note-takers and researchers get the most out of it. Small teams can share a vault through git. Medium and large teams should not expect a multi-user story, because there is not one. The catch is the agent bill. Every ingest and wiki-build pass burns a lot of tokens against whatever agent you point at it, and re-linting a large vault is not cheap. The sharper catch: an agent that writes your notes writes its mistakes into them confidently. Source traceability tells you where a sentence came from, not whether it is true.
Free and MIT licensed with nothing gated. Your real bill is agent tokens during ingest and lint runs, which point-at-Ollama reduces to zero.
### What's Free Everything. MIT licensed. All 15 skills, every methodology mode, transactional operations with rollback, Canvas generation, and the linting and retrieval tooling. No account, no server, no paid tier. ### Deployment Cost $0 in infrastructure. Python 3.11+ and bash. Your vault is a directory on your own disk. Git is only needed if you want checkpoints or want to share the vault with someone. ### The Real Cost Agent tokens, and this is the whole cost story. Ingesting a source, building wiki pages, and linting a vault are all multi-pass agent operations. A large vault relinted end to end is a meaningful chunk of a monthly agent budget. Point it at Ollama if you want that number to be zero and are willing to trade quality. ### Reducing It Ingest incrementally rather than in bulk, and scope lint runs to the folders you actually changed. The transactional rollback makes it safe to abort a run that is going long. ### vs Alternatives Obsidian itself is free for personal use, with Sync at $4/mo and Publish at $8/mo. This adds the agent layer on top and does not replace either. Notion AI is $10/user/mo and keeps your notes in Notion's database, which is exactly the tradeoff this project exists to avoid.
OpenBot gives every agent its own computer. Not a sandboxed shell, an actual browser with its own logins, its own files, and only the tools you granted it, so the agent that books travel never holds the credentials that could send email. Every action is decided before it runs and recorded after, which is the part most agent frameworks skip. MIT licensed, from the CopilotKit team. Any AG-UI agent plugs in, written on a framework or by hand, and shows up as a coworker with its own channel. You watch it work on its own screen, take the wheel when it reaches something it should not do alone, and hand control back. It answers with rendered components rather than only prose, which makes reviewing its work faster than reading a transcript. Running it means containers, browser sessions, and credential storage per agent. That is real infrastructure, not a CLI. Solo builders can run it locally. Teams should plan for isolation between agents from the start. The catch is age. This shipped in August 2026 and moves daily. The permission model is the whole value proposition here, and a permission model with a week of production history has not been tested by anyone who wanted to break it.
OpenBot is MIT and free to self-host in full. CopilotKit's paid platform starts at $39/mo and is a separate product, not a license for this.
### Free (Self-Hosted) OpenBot itself is MIT licensed and complete. The agent runtime, the per-agent browser and filesystem isolation, the approval flow, and the generative UI layer are all in the repo. Nothing is stripped out to sell back to you. ### Self-Hosted Costs You are running a browser and a workspace per agent, so this is heavier than a chat wrapper. A few agents on a $20 to $80/mo VM is realistic; a fleet wants real orchestration. Model tokens are separate and will dominate the bill: an agent that browses burns context fast. ### Paid (Vendor Context) CopilotKit, the company behind it, sells a separate commercial line: Free, Pro at $39/mo, Team at $100/seat/mo up to 5 seats, and Enterprise by quote. That is the CopilotKit platform, not an OpenBot license. You can run OpenBot without ever touching it. ### When to Pay CopilotKit's platform is worth it when you want hosting and support and support around production agents. Self-host OpenBot when the point is that credentials and browser sessions never leave your infrastructure, which is most of the reason to pick it.
Ponytail is a plugin that talks your coding agent out of writing code. It installs a decision ladder the agent has to walk before it types anything: can this be skipped entirely, can existing code be reused, is there a standard library function, is there already a dependency that does it, can it be one line. Building something new is the last rung. MIT licensed, nothing to host. What started as a Claude Code skill now covers roughly twenty harnesses, each with its own install command: Codex, Copilot CLI, Cursor, Windsurf, Cline, Zed, Gemini CLI, Aider. Node on your PATH is the only hard requirement, for the lifecycle hooks. Six commands cover mode control, review, audit, tech debt, and a gain report, and three intensity levels dial how aggressive it gets. The project's own benchmark on FastAPI and React edits claims 54% fewer lines, 20% lower cost, and 27% faster runs. Treat a maintainer's benchmark as directional rather than settled. Solo developers: the token savings alone repay ten minutes of setup. Small and medium teams: worth standardizing so agent output looks the same across the team. Large teams should wire the audit and debt commands into review. The catch is that "write less code" is a preference, not a law. Push an agent hard enough toward minimalism and it will reach for a dependency that does not quite fit, or skip an abstraction you wanted. Start on lite, read what it declines to build, and turn it up once you trust its judgment.
Completely free and MIT licensed, and it is one of the few free tools that measurably lowers a bill you are already paying.
### What's Free All of it. MIT licensed. Every mode, all six commands, and every platform integration. No account, no telemetry gate, no paid tier. ### Deployment Cost $0. It is a plugin or rules file installed into an agent you already run. Node.js on PATH is needed for lifecycle hooks on Claude Code and Codex. Optional config lives at ~/.config/ponytail/config.json. ### The Real Savings This is one of the rare free tools with a direct cost argument attached. Fewer generated lines means fewer output tokens, and the project benchmarks roughly 20% lower cost and 27% faster runs on real repository edits. On a team burning a few hundred dollars a month in agent spend, that is real money for a one-time setup. ### The Real Cost Review attention. A minimalist agent makes different mistakes than a verbose one, and they are quieter: reused code that almost fits, missing abstractions, dependencies pressed into service. Budget the review time you save on volume back into reading what it chose not to build.
Caveman strips the fluff from Claude Code responses. Install it with one command, activate with /caveman, and your AI assistant drops the pleasantries, hedging, and filler words while keeping full technical accuracy. Average savings: 65% fewer output tokens. Multiple intensity levels: Lite stays professional but terse, Full drops articles and uses fragments, Ultra goes telegraphic, and Wenyan variants compress into classical Chinese. Code blocks, error messages, git commits, and technical terms pass through untouched. Version 2 added a compression engine that squeezes model input as well: tool outputs, logs, and JSON get compacted before they hit your context window, and a companion tool rewrites your CLAUDE.md and memory files to cut input tokens too. It works across 30+ AI coding agents, not just Claude Code. Cursor, Copilot, Windsurf, Cline, Codex, all supported. Heavy token users will feel the difference in both speed and cost. The catch: it started as a meme but the benchmarks are real, backed by a real 2026 research paper. Ultra mode can be hard to read. And v2 split the licensing: the skill, CLI, and SDKs stay MIT, while the engine, proxy, and platform components moved to BSL-1.1, free to self-host including production, only blocking resale of Caveman as a service. The split is per-component, so the LICENSE file in each package is the authority.
Free everywhere, including production self-hosting. The MIT/BSL split only bites if you resell it as a service.
**Free:** Everything, for everyone actually using it. The skill, CLI, and SDKs are MIT. The v2 engine, proxy, MCP, and platform components are BSL-1.1: free to self-host, including production use. **The only restriction:** Selling Caveman itself as a hosted service requires a commercial license. The BSL components sunset to Apache-2.0 in roughly four years. **Note:** The split is per-component, so check the LICENSE file in each package rather than assuming one license covers the repo.
OpenAI's Codex agent packaged as a Claude Code skill plugin. It lets you invoke Codex from inside Claude Code to review code or delegate tasks, connecting two AI coding agents so they can collaborate. Useful if you want a second opinion from a different model without switching tools. The integration is straightforward: install the skill, and you can ask Claude Code to hand off specific tasks to Codex. Code review is the primary use case, where having two different models look at the same code catches more issues than either alone. The catch: requires both Claude Code and OpenAI API access, so you're paying for two AI services to talk to each other. The value proposition only makes sense if you're already invested in both ecosystems. For most developers, one AI coding tool is enough.
Free plugin, but you are paying for both Claude and OpenAI API usage to run it.
The plugin itself is free and open source. You need active subscriptions to both Claude Code and OpenAI's API to use it. Your real cost is the combined token usage across both services.
get-shit-done-redux is a system for keeping AI coding assistants reliable over long sessions. The problem it targets is context rot, the quality drop that happens as an agent fills its context window and starts forgetting what it was doing. GSD fixes this with a structured command loop and fresh subagent contexts, so the main window stays uncluttered. It works with Claude Code, OpenCode, Gemini CLI, and others. MIT licensed and free. The workflow is six commands: start a project, discuss the phase, plan it, execute through parallel agents, verify the result, then ship and repeat. Each executor gets its own clean context window, which keeps your primary session running at a fraction of capacity instead of choking on accumulated history. Install is a single npx command, so there is almost nothing to set up. Solo developers who run long agent sessions and watch quality degrade will get the most out of this. Small teams adopting a shared agent workflow can standardize on the same command loop. It is free at every scale, so the only cost is learning the discipline it imposes, which is the actual point. The catch is that this is methodology wrapped in tooling. It only helps if you commit to the loop. Bolt it onto a chaotic workflow and you will get chaos with extra steps. The structure is the value, and structure takes buy-in.
Completely free and open source under MIT. The only cost is the API usage of whatever AI assistant you run it with.
**Free tier:** Everything. MIT licensed, installed with a single npx command. **Self-hosted:** Not applicable in the usual sense. It is a command system layered onto your existing AI coding assistant, running locally. **Paid:** None. You pay only for the underlying assistant's API usage (Claude Code, Gemini CLI, and so on), which you were paying for anyway.
video-shotcraft is a skill you install into Claude Code or Codex that turns your coding agent into a motion-design studio. Ask it for a product video and it storyboards, animates real page captures with 3D camera moves, syncs cuts to a beat, and adds sound design, then renders the whole thing through Remotion. Apache-licensed, no API keys, free.
It installs with npx skills add and runs inside the agent and Remotion toolchain you already have. Node 22, and if you're rendering headless on Linux you'll need a Chrome headless binary and low concurrency on small machines. Moderate setup, mostly because of the render pipeline, not the skill itself.
This is the same pattern as the best agent skills: heavy, reusable assets (over a hundred shot recipes, motion previews, sound effects, ready-made Remotion components) plus a documented method, so the agent isn't improvising from scratch. For a solo developer or small team that needs product videos and doesn't want After Effects, it's a useful free option that lives right in your editor.
Two catches. First, only one finished template ships today, so you're getting a strong framework with more promised rather than a full library right now. Second, it leans on Remotion, which is free for individuals and small teams but can require a paid license for companies, so check that before you ship commercial work. The skill is free; the render engine's licensing is the fine print.
The skill is free (Apache 2.0), no API keys. The render engine it uses, Remotion, is free for individuals but can need a paid company license.
**Free:** The whole skill, shot recipes, motion previews, sound effects, Remotion components. No API keys. **Self-hosted:** Installs into Claude Code or Codex via `npx skills add`, renders through your own Remotion toolchain. **Paid:** None from the skill. Remotion is dual-licensed and companies may need a paid Remotion license.
Baoyu-design turns your AI coding agent into a UI designer. Describe a screen and it generates a polished, self-contained HTML mockup, prototype, wireframe, or even a slide deck, right inside Cursor or Claude Code. It's a local, MIT-licensed take on Anthropic's claude.ai/design feature, so you get that capability without the hosted product. It has grown fast. Version 1.2 added routing across 13 project types plus workflows for 3D objects, data visualization, HTML email, maps, and landing pages, on top of the design-system, deck, and mobile-layout skills it started with. Output is self-contained HTML with exports to PDF, editable PowerPoint, and into Figma or Canva. Install is a single command through the skills CLI, and it works across Claude Code, Cursor, Codex, and a long list of other agents. This is the open alternative to claude.ai/design, and it overlaps Figma AI, v0, and Lovable for spinning up mockups fast. It does not replace Figma as a collaborative design tool; it replaces the "generate me a first draft" step. Solo builders and small teams who want quick UI drafts: install it and go. The catch: quality leans hard on running a strong model, Opus 4.8 specifically, inside a paid coding agent, so "free" assumes you already pay for the agent underneath. It's also solo-maintained and reshaping itself release to release, so expect the shape of it to keep changing.
Free and open source (MIT). The catch: it runs on top of a paid AI coding agent, and works best with Opus 4.8.
**Free:** The skill itself, under MIT. Sub-skills across 13 project types: mockups, prototypes, decks, 3D objects, data viz, HTML email, maps, landing pages, and exports. **Self-hosted:** Nothing to host. One `npx skills` command installs it into Cursor, Claude Code, Codex, or another compatible agent. **The cost is the agent underneath:** It generates designs by driving a paid AI coding agent, and it's tuned for Opus 4.8, so the real spend is your agent subscription or API usage. The hosted thing it replaces, claude.ai/design, is Anthropic's own version of this.
dbskill is a pack of 30 business skills you install into a coding agent. Not code skills. Business ones: pricing diagnosis, competitor benchmarking, content topic development, headline and short-video hook optimization, decision logging. The content was mined from roughly 16,000 public tweets by the creator and distilled into structured knowledge the agent can call. Install is one npx command and it works with Claude Code, Codex, Dou Bao, WorkBuddy, and other agents that support the skills format. There is nothing to host and no API key of its own. One thing to know before you try it: the skills are written in Chinese, so the frameworks and the prompts you get back are in Chinese unless you translate them. The value is the structure rather than the intelligence. Instead of improvising a prompt every time you want to pressure-test pricing, you call a skill that already knows which questions to ask in which order. Solo founders and content creators are the real audience. Engineering teams will not find much here. The catch is the license, and it is a real one. This is CC BY-NC 4.0, which means non-commercial use only. Using these skills to run your own business is exactly the commercial use that license restricts, and you need separate authorization from the author. That is an odd shape for a business toolkit, so read the terms before you build a workflow on it.
Free to install but licensed CC BY-NC 4.0, so commercial use needs the author's permission. Read the license before building a business workflow on it.
### What's Free All 30 skills, installed with a single command. No account, no API key, no server. The skill files are plain text you can read before you run anything. ### The License Catch CC BY-NC 4.0. Personal and non-commercial use is permitted; commercial use requires separate authorization from the author. This is not an OSI-approved open source license, and the non-commercial clause is the whole story for a toolkit aimed at entrepreneurs. Free to try, restricted to deploy. ### Deployment Cost $0 to install. Requires Node.js and npm. Version 2.18.22 added automatic daily version checking with a one-command update, so keeping current is not a chore. ### The Real Cost Agent tokens and language. The skills run through whatever agent you already pay for, and they are written in Chinese, so an English-speaking user is paying translation overhead on every output. ### Who Should Skip It Engineering teams. These are business analysis and content marketing frameworks, not development tooling.
Skill-recorder watches you do a task once and turns it into a skill your AI agent can repeat. It's a Microsoft desktop app that records your screen session (window switches, URLs, optional spoken narration), then uses the GitHub Copilot CLI to reconstruct what you did as an intent plus ordered steps, packaged as a reusable skill file or a scheduled automation. MIT licensed and free. The smart design choice is that it generalizes instead of replaying. Show it one form submission and it writes a procedure for handling forms, reaching for native tools like the GitHub CLI instead of scripting browser clicks. Recording and Whisper transcription stay on your machine, but hitting Analyze ships window titles, URLs, clipboard previews, and screenshots to GitHub's cloud. The README tells you flat out not to record credentials. That warning is honest, and it also rules out most real admin workflows. This only makes sense inside Microsoft's agent ecosystem. The output targets Microsoft Scout, Copilot Cowork, and Copilot Studio, and you need GitHub Copilot access to run the analysis. If you live in that stack, install it. If you don't, the skills it produces have nowhere to go. The catch: the recorder is free, the destinations aren't. Copilot Cowork needs a Microsoft 365 Copilot license at $30/user/mo plus usage billing, and the app is weeks old. MIT on the recorder doesn't buy portability of the result.
The recorder is free. The ecosystem it feeds (GitHub Copilot, Microsoft 365 Copilot) is where the bill lives.
**Free:** The app itself, MIT licensed, with installers for macOS, Windows 11, and Ubuntu. Local recording and on-device Whisper transcription cost nothing. **The dependency:** Analysis runs through the GitHub Copilot CLI, so you need Copilot access. Copilot Free exists but is limited; Pro is $10/mo, Business $19/seat, and paid tiers meter CLI usage through bundled AI credits. **Downstream:** The skills it produces target Microsoft Scout, Copilot Cowork, and Copilot Studio. Cowork requires Microsoft 365 Copilot at $30/user/mo and bills usage per task run on top. The recorder is the free front door to a metered building.
Wewrite is a Claude Code skill that handles trending topic research, topic selection, article writing, SEO optimization, and publishing. Built for the Chinese content market. The pipeline goes from identifying trending topics on Chinese social platforms to generating articles optimized for WeChat's distribution algorithm. It covers the entire workflow that content teams typically do manually across multiple tools. The catch: Chinese-language tool for a Chinese platform. If you don't publish on WeChat, this is not for you. AI-generated content at scale raises quality questions regardless of platform, and WeChat has its own content policies around automated publishing that you need to understand before running this at volume.
Free skill. Requires Claude Code subscription.
Fully open source. A Claude Code skill. No hosting, no paid tier. Requires Claude Code subscription.
Phone-harness lets an AI agent physically drive your iPhone. It captures the macOS iPhone Mirroring window, runs Apple's OCR over it for eyes, and posts real taps, drags, and keystrokes for hands. No jailbreak, no Xcode, about 500 lines of Python, MIT licensed and free. Setup is a one-time iPhone Mirroring pairing plus Accessibility and Screen Recording permissions, and a doctor command checks the chain. The design constraint is that the mirroring window is just a video stream: no accessibility tree, so anything not rendered as readable text is invisible to the agent, and the window must stay frontmost, so your Mac is occupied while it runs. This is a proof of concept for people experimenting with agent-driven mobile automation, not a QA tool; Appium and Maestro remain the serious answers for testing. And it does not work in the EU at all, because Apple has never shipped iPhone Mirroring there. The catch: you're giving an LLM unsupervised control of your personal, logged-in phone with nothing sandboxing it. Very young, tiny commit history, and the issue list is already outrunning the code. Fun to try; think hard before trusting it.
Completely free and open source. The cost is trust: an LLM gets unsandboxed control of your real phone.
**Free:** Everything. MIT, no commercial offering. **Requirements that gate it:** macOS Sequoia or later, an iPhone paired via iPhone Mirroring, Accessibility and Screen Recording permissions. Unavailable in the EU because iPhone Mirroring has never shipped there. **The trade:** Free phone automation in exchange for handing an LLM live control of your logged-in device.
sepia is a writing skill that attacks AI tells at the structural layer instead of the word layer. Most humanizers swap vocabulary and shuffle syntax. sepia cites StoryScope, a 2026 study of 61,608 stories, which found a classifier using narrative-structure features alone identifies AI fiction at 93.2% macro-F1 and barely drops when surface style is edited away. So it works on the architecture: narrators who explain the theme, causally tidy single-track plots, emotion rendered only as bodily sensation, no real-world references, endings resolved by growth and acceptance. MIT licensed. It installs as a portable Agent Skill, so any agent speaking that spec can load it, with native plugin packaging verified on Claude Code, Codex, Grok Build and Antigravity. One canonical SKILL.md, no per-platform forks. Four operations: write, review (diagnose only), refactor (minimal edits), and recreate (full rewrite). Professional prose gets its own rule files per venue, covering release notes, PR replies, postmortems, tickets and technical articles. Free with no tiers. Anyone whose drafts come out sounding like a model wrote them gets real value, especially on the professional side where the rules are concrete: answer first, cite file and line, no reflex praise, length proportional to stakes. The catch is that this is a prompt, not a guarantee. It calibrates toward the human distribution rather than inverting the AI one, which is the right instinct, but nothing here beats an actual detector and treating it as a compliance tool would be a mistake.
Completely free and open source under MIT. It is a skill file, so the only cost is the tokens your agent spends running it.
### Free (Open Source) - MIT licensed, distributed as a portable Agent Skill under the agentskills.io specification - Installs via the Skills CLI (skills.sh) with one command; native plugin packaging for Claude Code, Codex, Grok Build and Antigravity - Four operations: write, review, refactor, recreate - Three-pass fiction protocol plus a 30-feature diagnosis rubric and per-model fingerprint corrections - Venue-specific rule files for release notes, PR and issue replies, postmortems, tickets and technical articles - Research digest of the underlying studies included in the repo ### Paid None. There is no hosted service or paid edition. ### Self-Hosted Costs $0 beyond the tokens it consumes. It is Markdown loaded into an agent session; a full rewrite pass costs whatever your model charges for the context and output. ### When to Pay Nothing to buy. The cost is context and your own judgment about the output.
Drama Skills is a ten-skill pipeline for producing AI short dramas and motion comics, the vertical-video serial format that is enormous in China and creeping into Western apps. Hand it an idea or a long source text and it carries the work through episode scripts, visual continuity, storyboards, image and video prompts, generation, and a cut list that renders into a finished film. MIT, Python 3.9 or newer, running inside Claude Code, Codex, or any runtime that supports Agent Skills. The interesting part is where it came from. The team ran a motion-comic studio through more than a thousand projects and roughly 80,000 lines of in-house GUI tooling, then threw the GUI away and distilled the whole line into skills that operate on plain Markdown. Each episode is five files. Confirmation comes before production: prompts land in files first, and the production skill shows you the exact count, references, parameters, and adapter before it executes anything. Anyone producing serialized AI video at volume should look hard at this. Everyone else probably should not. The value is workflow discipline, not any individual prompt, and that only pays off past a certain output rate. Free at every team size. The catch is language and the bill behind the pipeline. Project files are named in Chinese by default and the primary README is Chinese, with the English translation trailing it. The skills are free but the pixels are not: the production step drives external adapters with bundled profiles for Seedance, GPT Image 2, MiniMax video, and MiniMax Music, every one of them billed to your own keys. That confirmation gate exists because those runs cost real money.
Free and MIT. The bill is the image, video, and music APIs it drives, charged to your own keys.
**Free tier** All ten skills, MIT licensed, Python 3.9 or newer. Install by pointing Claude Code or Codex at the repository, or link the skills you want by hand. **Self-hosted** The only mode. The skills operate on plain Markdown inside your own project directory, credentials stay outside the project, and the non-production skills are provider-neutral. **Paid** Nothing goes to the project. Generation is where the money goes: the production skill drives external adapters with bundled profiles for Seedance, GPT Image 2, MiniMax H3 video, and MiniMax Music, all charged to your own API keys. The preview-and-confirm step before each run exists because those jobs are not cheap.
Paw Work is a Chrome extension that turns a web page into raw material for an AI agent. You flip on Paw Mode, click the parts of a live page that matter (product photos, a table, a block of copy), then describe the outcome you want, and it hands back an editable file: a spreadsheet, an 8-page deck, a poster, a document, or a working HTML site. Bring your own model key; it is MIT and there is no server. The selection-first idea is the point. Instead of dumping a whole page at a model and hoping, you point at exactly what you want and the agent works from that. Generated code runs in a sandboxed QuickJS VM that never touches the page DOM or your other files, and complex jobs show you a plan card to approve before anything is written. Your keys stay in the browser and go only to the endpoints you set. For turning messy web content into something you can actually edit and keep (decks, comparison sheets, docs) this is a sharp little tool, and the privacy model is better than most browser agents. The catch: it is not on the Chrome Web Store yet, so you load an unpacked extension yourself, and quality rides entirely on whatever model key you plug in. Early, but the approach is right.
The extension is free and open source. You pay only for whatever model API key you bring.
**Free:** Paw Work is MIT and open source. The extension has no paid tier, no account, and no Paw Work server. **Self-hosted:** It runs as an unpacked Chrome extension on your own machine (not yet on the Chrome Web Store). Model keys live in the browser and are sent only to the endpoints you configure. **Paid:** None from Paw Work. It is bring-your-own-key, so your only cost is whatever the model provider (OpenAI, Claude, etc.) charges for the API calls you make.
GSD-2 is a framework for keeping AI agents on track through long, complex tasks by giving them structured context and spec-driven goals. If you've used AI coding agents and watched them lose the plot halfway through a big refactor, this is the fix. The core idea is 'context engineering': you define specs that describe what the agent should build, break work into phases, and the framework ensures the agent always has the right information at the right time. Specs look like structured documents with acceptance criteria, constraints, and dependencies. Instead of the agent drowning in its own conversation history, GSD-2 feeds it focused context windows that keep each step scoped and grounded. The catch: it is growing fast, but the API is still evolving. Docs are catching up. This is a bet on a concept (structured agent orchestration) rather than a stable production tool. If you need something battle-tested today, look at established agent frameworks. If you want to experiment with the next wave of agent reliability, this is worth watching.
Free. The framework itself costs nothing; you pay for the LLM APIs it calls.
Fully open source under MIT. No paid tier, no hosted service. You install it as a development framework alongside your agent setup. The only cost is whatever LLM you run through it.
This turns "make me a loading spinner animation" into actual Lottie code through your AI coding agent. Lottie is the format apps use for lightweight vector animations, and creating them normally means After Effects and a plugin. diffusionstudio/lottie installs as a skill for agents like Claude Code, then converts an SVG or a plain-text description into working animation code you can drop into web, React Native, iOS, Android, or Flutter. Setup is one command, npx skills add diffusionstudio/lottie, and you're generating animations by prompting. There's nothing to host and no account. Because it produces standard Lottie JSON, the output plugs into the same players and tooling you'd already use. The whole thing is MIT-licensed and free. Developers who need simple animations but don't have a motion designer, or don't want to learn After Effects, are the target. It won't replace a real animator for complex, hand-crafted motion work. For spinners, icon transitions, and straightforward UI animation, it's a fast path from idea to code without leaving your editor. The catch: it leans on your AI agent, so the quality of what you get tracks the quality of your prompt and your model. Intricate animation is still beyond what a text prompt produces cleanly, this shines on the simple-to-moderate stuff. Think of it as a head start, not a finished motion-design studio.
Free and open source (MIT). You only pay for your agent's model usage.
**Free tier:** Free and open source under MIT. No paid version. **Self-hosted:** It's an agent skill you install locally, nothing to host. Free. **Paid:** None from the project. You pay only for whatever LLM your agent uses.
scroll-craft is a Claude Code skill that builds scroll-driven websites and refuses to make them generic. In plain terms, it is a plugin for Claude Code that generates high-end animated landing pages where scrolling drives the whole experience: video scrubs frame by frame, sections pin while their point advances, headlines assemble line by line. MIT licensed, free to install. The interesting part is the guardrails. Most AI-generated sites fail in one of two directions, either forgettable or flashy-but-broken, with unreadable contrast and headlines that wrap to six lines on a phone. scroll-craft encodes a typography floor, a real spacing scale, and a fingerprint gate that forces each build to differ from the last so two pages cannot quietly converge into the same template. Then it drives a headless browser over the finished page to catch dead scroll and measure contrast per line on the composited page. Setup wants Node 18+, a full ffmpeg build, and Playwright, and the README is honest that a stripped-down ffmpeg is the most common thing that breaks. Who should use it: anyone working in Claude Code who builds marketing or landing pages and is tired of the same six-section AI layout. Solo devs and designers get it free. Teams can point it at a brand kit and its hard rules win, which makes it more reliable than a one-off prompt. The catch: it is a skill, not a product, so output quality rides on Claude Code and on your inputs, and the toolchain is finicky to stand up. The self-verification is genuinely clever, but as the author admits, a machine can prove a page works and still not tell you it means anything. That last mile is yours.
Free and MIT licensed. It runs on Claude Code, so the only cost is your existing Claude usage.
**Free tier:** The whole skill. MIT licensed, install it into Claude Code at no cost. **Self-hosted:** It runs locally through Claude Code. You supply Node 18+, a full ffmpeg build, and Playwright. No servers, no accounts, no sign-up. **Paid:** The skill is free, but it runs on Claude Code, which needs a Claude subscription or API usage. That is your only recurring cost, and it is Anthropic's, not this project's.
Oil-motion is an agent skill that manufactures scroll-driven web animations using AI video generation. The agent locks keyframes, has a video model fill the motion between them, reviews the frames, and ships a sprite sheet or chroma-keyed MP4 wired to scroll position. At 30% scroll you see frame 30. MIT licensed, but the workflow requires a paid ZenMux API key, so every animation costs real money per generation. Setup is Python, Pillow, and ffmpeg plus the key, and the pipeline expects a human to approve keyframes and review output. The skill's docs are in Chinese, which matters since the agent reads them to do the work. Its own docs draw the right line: for ordinary translation, scale, and rotation, write code; GSAP and Motion do that deterministically and free. The paid generation only earns its cost for what it calls semantic motion, product teardowns and material changes that CSS transforms can't fake. The catch: output is baked at build time, regeneration can drift your product's proportions, and days-old viral projects have no track record. A hand-built GSAP timeline is still the default answer.
The skill is free; the workflow is not. Every animation bills through the required ZenMux video API.
**Free (the skill):** MIT code, no tier of its own. **Paid (the dependency):** Requires a ZenMux API key; the default video model bills per generation, and iterating on keyframes multiplies the cost per finished animation. **The trade:** You pay a video model to manufacture frames a GSAP timeline would produce free. Only defensible for motion CSS can't fake.
This skill connects your agent to your live Chrome via the Chrome DevTools Protocol (CDP). Your agent can read pages, click buttons, fill forms, and navigate, in the browser you're already using. The difference from tools like Playwright is that this connects to existing tabs. Your agent can interact with pages where you're already authenticated, see what you see, and do what you'd do manually. MIT licensed, JavaScript. The catch: giving an AI agent access to your live browser session with all your logged-in accounts is a real security consideration. The agent can see everything you can see, including sensitive data in open tabs. There's no permission model beyond 'full access.' And CDP connections can be fragile; Chrome updates can break the protocol.
Free. Consider the security implications of full browser access.
Fully open source under MIT. No paid tier, no hosted version. Install as a skill and connect to your local Chrome. No cost beyond the Claude Code API usage.
headcount packages Claude Code skills the way a company packages people: 16 departments covering things like security, finance and engineering, 172 skills in total, each department installable on its own. Rather than dumping every skill into one project and hoping the model picks the right one, you add the departments a project needs. Skills are addressed as department:skill, so security:threat-modeling and finance:unit-economics never collide. MIT licensed.
Installation is two lines in Claude Code: add the marketplace, install a department. There is no server, no runtime, and nothing to keep patched. The whole thing is Markdown, which is also the honest description of what you are installing. An interactive org chart on the project site lets you search every skill and jump to its source before you commit to any of it.
Free, all of it, with no paid tier. Solo builders and small teams get the most value, since the appeal is scaffolding you did not have to write. Larger teams should read the skills they install rather than trusting the department label, because these become instructions your agent follows.
The catch is that 172 skills is a claim about volume, not quality, and the project is very new. Skill collections rot fast as the underlying agent changes, and a stale skill that confidently tells your model the wrong process is worse than no skill at all. Install the two departments you need, not all sixteen.
Completely free and open source under MIT. Installed through the Claude Code plugin marketplace, one department at a time.
### Free (Open Source) - MIT licensed, installed through the Claude Code plugin marketplace - 16 departments, 172 skills, each department independently installable - Namespaced addressing (`department:skill`) so names never collide across departments - Interactive searchable org chart with links to every skill's source - No account, no server, no telemetry ### Paid None. There is no hosted tier or commercial edition. ### Self-Hosted Costs $0. These are Markdown skill definitions loaded by Claude Code. The only cost is the context they consume in your sessions, which is a real reason to install selectively rather than wholesale. ### When to Pay Nothing to buy. The cost is review time: read what you install, because these become instructions your agent acts on.
dream-loop makes AI coding agents better at visuals by giving them a picture to aim at. The agent first generates an image of what the finished scene should look like, builds toward it, then a separate critic agent compares a live screenshot against that target and sends notes. It loops until the critic is satisfied. MIT licensed, installed as a skill.
Install with npx skills add achimala/dream-loop or clone it into your skills folder. Your agent needs image generation, either built in like Codex or through an API key such as Gemini, plus vision input and ideally subagents. Blender is optional for custom 3D models, and the author prefers the Blender MCP over computer use.
Developers building browser games, 3D demos or visually heavy pages get the most from it. The showcase is a Three.js isometric fantasy scene from a one-hour, time-boxed prompt, with a live demo you can click around. The skill is free, but every loop spends image generation and model calls.
The catch is testing. The README says it has only been run with GPT-6 Astra in Codex, so on any other agent you are the test case. It is also a new repo from one developer.
Free under MIT. The cost is image generation and model calls on every loop.
**Free tier:** Everything, under MIT: the skill and its dream, build and critique loop. **Self-hosted:** Runs inside your own agent. Requires image generation (built in, or through an API such as Gemini), vision input, and preferably subagent support. Blender is optional for 3D modeling. **Paid:** None from the project. Image generation and model usage bill through whatever provider your agent uses, and each extra critique loop multiplies that.
anything2explainer turns a topic into a narrated motion-graphics explainer video. It is a skill for Claude Code or Codex, not an app: the agent researches with sources, writes the script, generates voiceover, storyboards every shot, then writes each shot as a Remotion component. You get a 720p MP4 with subtitles, chapter cards and a progress bar, in English or Chinese. Setup is real. You need Node 18+, ffmpeg, a Python environment with edge-tts, and kokoro plus espeak-ng for English voices. A 3 to 5 minute film takes about two hours with eight build agents working in parallel, and around 2 GB of disk. It stops at four checkpoints for your sign-off, including a 30-second preview before the full build. Solo creators and educators who want explainers without learning After Effects get a lot here, and every shot is code you can fix one file at a time. Hours of parallel agents also means a real model bill. The same author's video-shotcraft covers product videos under Apache 2.0. The catch is two licenses. The skill is PolyForm Noncommercial, so commercial use needs the author's permission. Remotion underneath needs a paid license, $25/mo per seat, once your company passes three employees.
Free for noncommercial use only. Businesses need the author's permission, plus Remotion seats at 4+ employees.
**Free tier:** Free for noncommercial use under the PolyForm Noncommercial License 1.0.0: the Remotion template, the primitives and lighting library, voiceover, storyboard, render and QC scripts, the style and motion specs, the multi-agent protocol, and a complete reference film. Bundled fonts are under the SIL Open Font License. Videos you produce belong to you. **Self-hosted:** Runs locally inside Claude Code or Codex. Requires Node 18+, ffmpeg, Python with edge-tts, and kokoro plus espeak-ng for English narration. No GPU needed, since Remotion renders on the CPU through headless Chromium. The default Chinese voice calls a Microsoft endpoint; the default English voice runs locally. Developed on macOS and verified on a Raspberry Pi 5; Windows is untested. Your real costs are agent tokens and 2 to 3 GB of disk per project. **Paid:** The author sells no tier, but any commercial use of the toolkit requires their prior authorization. Remotion is free for individuals, nonprofits and companies with up to three employees; larger companies need a Remotion company license, which starts at $25/mo per seat.
beautify-github-readme is an agent skill that redesigns your project's README. It reads the actual repository first, works out what the project does and what evidence exists that it works, then builds a page around that: custom SVG title art, a real content hierarchy, and embedded proof. Install with npx skills add oil-oil/beautify-github-readme. MIT licensed.
Two modes: a full README redesign, or assets only when you just want a hero image or a diagram and intend to write the copy yourself. The constraint that matters is that it keeps text in Markdown rather than baking it into images, so the README stays searchable and diffable. Plenty of pretty-README templates fail exactly there.
Maintainers of small and mid-size open source projects get the most out of this, especially anyone whose README is currently a wall of installation steps. Larger projects usually have design help already. Free, with the cost being whatever agent you run it through.
The catch: the entire pitch is that it derives a project-native look rather than stamping one template, and the four sample heroes genuinely do look nothing alike. Whether that holds after a few thousand repos push their READMEs through the same skill and the same model is the open question, and nobody knows yet. Use it for structure and hierarchy, which is where the value sits either way, and give the generated art a hard look before you ship it.
Free and MIT. Costs a one-time chunk of agent tokens per README.
MIT licensed and free. No paid tier and no hosted service. It installs as a skill through `npx skills add` or by asking your agent to install it, and runs inside whichever agent harness you already use. The only cost is the tokens spent reading your repository and generating the assets, which is a one-time expense per README rather than anything ongoing.
Pixel2motion takes a static logo and turns it into an animated SVG, through your AI coding agent. Hand it a PNG, JPG, or WebP and it produces a smooth animated vector, an interactive HTML demo, GIF and video previews, and automated checks on the animation quality. It is aimed squarely at brand and logo motion work, MIT-licensed and free. Setup is heavier than most agent skills. The rendering and QA run locally and lean on a real toolchain: Python 3.10+, Pillow, NumPy, and Playwright driving a headless Chrome. So 'install and go' here means installing that stack first. It is also young, around twenty commits, and tied to running inside Claude Code or Codex rather than working standalone. This is for designers and developers who already live in an AI agent and want logo animation without opening After Effects. Solo or team, it is free. Skip it if you do not work inside an agent, or if you only need a single animation, in which case a motion designer or a one-off tool is less setup than standing up Playwright and Chrome. The catch is the toolchain and the maturity. The idea is sharp and the built-in QA step is a nice touch, but you pay for it in local dependencies and early-project rough edges. For polished, hand-crafted brand motion, this is a starting point, not a replacement for a real animator.
Completely free and open source. The heavy local toolchain is the real cost.
**Free tier:** Fully free and open source under MIT. **Self-hosted:** Runs locally inside an AI agent. Requires Python 3.10+, Pillow, NumPy, Playwright, and a headless Chrome/Chromium to render and QA the animations. **Paid:** None. The proprietary route for this work is After Effects plus a Lottie export workflow.
Describe a card and get back a holographic collectible that shimmers as you drag it around the browser. holo-card-studio is an agent skill rather than an app: the agent paints four layers (subject, background, line art, text), builds a Blender scene with parallax and foil and sparkle, exports the geometry, and assembles a Three.js page that rebuilds the same look in the browser. MIT, and the skill itself is just scripts and text. Setup is lighter than it sounds. You need Python with Pillow and Node with npm. Blender it fetches on its own, pulling an official portable build into the project folder and verifying the SHA-256, so nothing lands system-wide. It ships as a Codex skill and leans on the agent's built-in image generation, and its instructions explicitly forbid quietly substituting a paid image API. Solo and hobbyist: this is the fun one. Small teams have real uses, character cards for a game, conference giveaways, onboarding cards for new hires. Large teams: no. The catch: the Blender file and the web page are two separate implementations of one effect. glTF does not carry a custom shader graph, so the Three.js viewer rebuilds it with matching UV math. Edit the materials in the .blend and the page will not follow you.
MIT and free. The real requirement is a Codex plan with image generation, which the skill uses rather than any paid API of its own.
### Free The entire skill: SKILL.md, the art-direction and verification references, and the scripts that build the Blender scene, export geometry, generate transparent typography, validate the four layers, run the pipeline, and package the skill for sharing. MIT licensed. The responsive Three.js viewer template is included. ### Self-Hosted This is the only way to run it. Requirements are Python 3 with Pillow, Node.js with npm, and an agent that can generate images. Blender is not a prerequisite: `ensure_blender.py` downloads an official portable build into the project directory and validates its SHA-256, so nothing is installed system-wide. Blender's interface defaults to Simplified Chinese in the project-local config and can be switched. ### Paid Nothing in the project itself. The cost sits upstream: this ships as a Codex skill, so it runs on whatever OpenAI plan gives you Codex plus image generation, and the layer generation consumes that plan's usage. The skill's instructions specifically tell the agent not to fall back to a keyed or paid image API without saying so. ### The Math Compare it against commissioning card art, which starts in the tens of dollars per card and takes days per round. This produces a full set in an afternoon on an agent subscription you probably already pay for. The tradeoff is that the output looks like generated art, because it is. ### Verdict Free, well documented, and unusually careful about not spending your money behind your back. You need a Codex plan with image generation to run it at all.
This turns Sahil Lavingia's Minimalist Entrepreneur methodology into Claude Code skills. Ten of them install through the plugin marketplace: find a community, validate an idea, scope an MVP, processize, find first customers, set pricing, plan marketing, grow sustainably, define company values, and run a minimalist review. Instead of reading the book and trying to apply it, you invoke a skill and the agent, prompted to act as an advisor channeling the book's philosophy, walks your specific situation through the framework. It asks questions, works through your answers and hands back structured output. The skills are free; you need Claude Code to run them. The catch is that this is one founder's business framework, not a technical tool. Output is only as good as your inputs, and if you disagree with the minimalist approach you will disagree with the advice. The repo has not been updated since April and ships no LICENSE file, only an MIT declaration in its plugin manifest, so be careful about reusing the prompts.
Free skills. You need Claude Code to run them, and the book is optional.
**Free tier:** All 10 skills, free to install and use. The plugin manifest declares MIT, but the repository contains no LICENSE file. **Self-hosted:** Nothing to host. Install through the Claude Code plugin marketplace, or clone the repo into your plugins directory. **Paid:** None. You need Claude Code to run the skills, and the book The Minimalist Entrepreneur is optional background.