Best Open Source Claude Code & Codex Skills

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.

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.

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.

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. Four intensity levels now: Lite stays professional but terse, Full drops articles and uses fragments, Ultra goes telegraphic, and Wenyan compresses into classical Chinese. Code blocks, error messages, git commits, and technical terms pass through untouched. Only the natural language gets compressed. A companion tool (caveman-compress) rewrites your CLAUDE.md and memory files to cut input tokens too. Works across 40+ 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 (Kevin from The Office) but the benchmarks are real, backed by a 2026 arxiv paper. Ultra mode can be hard to read. And the savings are output tokens only, so your thinking and reasoning costs stay the same.

Completely free and open source.

Career-Ops turns your AI coding CLI into a full job search command center. Paste a job URL, get a structured A-F evaluation against your CV with weighted scoring across 10 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, scans 45+ pre-configured company portals (Anthropic, OpenAI, Vercel, n8n), and can batch-evaluate offers in parallel using sub-agents. The Go-based dashboard lets you browse your entire pipeline from the terminal. 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, but now it also works with Gemini CLI, OpenCode, Copilot, and Qwen, 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 pre-configured portals skew 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.

This is a library of 1,900-plus reusable SKILL.md playbooks for coding agents. Skills are structured prompts that teach an agent how to do a specific job (write tests, harden a web app, run a data pipeline), and this repo collects them by domain and installs them into Claude Code, Cursor, Codex, Gemini CLI, and others with one command. MIT for the code, CC BY 4.0 for the docs, free. There is nothing to run. You point the installer at your tool of choice (`npx agentic-awesome-skills --claude` and so on) and it drops the skills into the right directory. It also ships domain plugins, curated bundles, and a browsable web catalog, so you can grab a focused pack instead of the whole thing. For anyone building an agent workflow, this is a fast way to skip writing every skill from scratch, and it costs nothing. Solo developers and teams get the same value; the skills are just files you version alongside your project. The catch is curation. Almost two thousand community skills means variable quality and a lot of overlap, and an installed skill is a prompt your agent will follow, so a sloppy or malicious one is a real risk. Treat these the way you treat any dependency: read the ones you actually install, do not bulk-install two thousand playbooks and hope. The value is in picking the right handful, not the size of the pile.

Free and open source. The real work is picking the right skills, not paying for them.

Ponytail is a skill that nudges your AI coding agent to write less code. It bakes in "lazy senior developer" instincts: reach for the standard library, use native language features, lean on dependencies you already have before writing anything custom. The pitch is that agents left alone tend to over-build, and ponytail pushes them toward the minimal solution a seasoned developer would actually ship. Setup is trivial, it installs as a skill or plugin and works across Claude Code, Codex, OpenCode, Cursor, Windsurf, and other agent platforms. There's nothing to host. It's MIT-licensed and free, and it's actively maintained, several releases deep. You add it once and it shapes how your agent approaches problems from then on. Developers who've watched an agent reinvent something the standard library already does, or bloat a file with code that didn't need to exist, are the audience. If you carefully review every line your agent writes anyway, the gain is smaller. The value is in steering output toward leaner, more maintainable code without you having to police it every time. The catch: it's a behavioral nudge, not a guarantee. It shifts the agent's tendencies, but the model still does what it does, and "minimal" is a judgment call it won't always get right. The claimed reductions in code volume are real in spirit, but treat them as a direction, not a promise. You're still the one who has to read what comes out.

Free and open source (MIT). You only pay for your agent's model usage.

OpenViking is a context database built specifically for AI agents. Instead of the usual pile of vector embeddings, it organizes an agents 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.

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.

Claude Obsidian turns your Obsidian vault into an autonomous knowledge engine powered by Claude Code. Instead of passive AI chat, it actively reads sources you drop in, extracts entities and concepts, creates cross-referenced wiki pages, and maintains a session context cache so the next conversation picks up where you left off. Ten skill commands cover everything from ingestion to vault linting to autonomous web research. Setup is a git clone and a shell script. The vault structure works directly in Obsidian with no plugin conflicts. It supports six wiki modes (Website, GitHub, Business, Personal, Research, Book/Course) and runs an 8-category vault linter that catches orphan notes, dead links, stale claims, and missing cross-references. Batch ingestion runs through parallel agents. Solo knowledge workers who already use Obsidian and Claude Code get a structured workflow for turning raw sources into an organized, interlinked wiki. The hot.md context cache is a clever solution to Claude Code's session boundary problem. The catch: you need a Claude Code subscription to run any of it, so it's free software that requires paid infrastructure. Heavy ingestion sessions burn through Claude Code context fast. The quality depends on prompt engineering that could break with model updates.

Free plugin, but requires Claude Code subscription ($20-200/mo) to function.

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.

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 or a CLI: you install it into Claude Code, Codex, or OpenCode and the agent runs the pipeline. MIT licensed. The design is the interesting part. Deterministic Python scripts, standard library only with no external dependencies, handle validation, quality gates, and code generation, while the model's tokens go only to the visual judgment steps: look at the image, assess it, review the render. That split is why it stays token-efficient, and it is a pattern more agent skills should copy. Web developers who need 3D objects and would rather not model them or license assets are the audience, mostly solo and small teams. Subjects get classified as object, character, or hybrid, and characters route through a separate anatomy-aware track rather than being refused outright. The skill costs nothing beyond the agent subscription you already have. The catch: it is strongest on hard-surface objects, and the project says so itself. Characters come out as stylized reconstructions, not photoreal likeness, and the projection-first likeness work is still on the roadmap rather than shipped. Credit where it is due, the skill is built to report low confidence and say the fidelity is not reachable from one image instead of confidently handing you something wrong.

Free and MIT. You pay only for the agent tokens the visual review steps consume.

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.

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.

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.

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: 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.

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.

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.

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 bundles two dozen specialized sub-skills for design systems, decks, mobile layouts, and exports, and it runs across Claude Code, Cursor, Codex, and a long list of other agents. Output is self-contained HTML, and it can export to PDF, editable PowerPoint, and into Figma or Canva. Install is a single command through the skills CLI. This is the open alternative to claude.ai/design, and it overlaps the territory of 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, throwaway 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 days old and solo-maintained, so durability is unproven.

Free and open source (MIT). The catch: it runs on top of a paid AI coding agent, and works best with Opus 4.8.

This is a prompt library that gives Claude structured frameworks for doing it. Picture pre-built consulting templates that turn Claude into a business analyst. What's free: Everything. It's a collection of Claude Code skills (prompt files) you drop into your project. No install, no dependencies, no account. The real value here is the structure. Instead of prompting Claude from scratch every time you need a SWOT analysis or process audit, these skills give it a repeatable framework. The prompts are well-organized and cover common business diagnostics. The catch: it's brand new (almost all growth in the last week), the description is partially in Chinese, and the license is listed as 'Other' which means you should read it before using commercially. The skills are also opinionated. They assume a specific diagnostic methodology that may not match how you work. And since these are just prompt files, the barrier to building your own is low.

Completely free prompt library -- your only cost is the Claude subscription you already have.

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.

pm-claude-skills is a library of ready-made skills you install into Claude Code or another AI agent to give it senior-professional workflows. Think PRDs, launch plans, and postmortems, around two hundred structured templates across twenty-plus fields, installed with one npx command and exportable to ChatGPT, Gemini, or Cursor. MIT, free. There is nothing to host; these are local Markdown files your agent reads. The value is entirely in the templates, so it lives or dies on whether the bundled frameworks match how you actually work. Across two hundred-plus skills the quality will be uneven, and a generic PRD template is only as useful as your willingness to adapt it. Treat it as a starting library, not gospel. This is for product managers and other knowledge workers using an AI agent who would rather start from a structured template than write every prompt from scratch. Solo or team, it is free. If you already have refined prompts you trust, or you bristle at one-size-fits-all frameworks, you will not get much from it. The catch is that this is content, not software. It does not make your agent smarter; it gives it scaffolding. Good scaffolding saves time. Generic scaffolding just adds a step. Skim what is in the box before you build a workflow around it.

Completely free and open source. Optional GitHub Sponsors tiers buy priority requests.

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.

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.

This turns Sahil Lavingia's entire Minimalist Entrepreneur methodology into executable Claude Code skills. Nine skills you install in your terminal: validate your idea, scope an MVP, find first customers, set pricing, and more. Instead of reading a book and trying to apply it, you invoke a skill and your AI walks through Sahil's exact framework applied to your specific situation. It's interactive: it asks you questions, processes your answers, and gives you structured output. The skills are well-structured and the methodology is proven (Gumroad was built on it). The catch: this is a business methodology, not a technical tool. The quality of the output depends entirely on how good your inputs are. And it's one person's framework; if you disagree with the minimalist approach, you'll disagree with the advice. No pricing page for the skills themselves: they're free, but the book is $17 on Amazon if you want the full context.

Free. Skills cost nothing; you pay for Claude Code, optionally $17 for the book.

gbro-collage-broll is an agent skill that turns a five-second voiceover line into a matching B-roll clip in an editorial halftone paper-collage style. Clone it into your agent skills directory and it walks a three-gate workflow: confirm the visual metaphor as text, approve a static frame, then generate the video. MIT licensed. Those gates are the design decision worth noting. Video generation is the expensive step, so the skill makes you sign off on the concept and then the still image before it spends anything. Requirements are a Codex environment, a Gemini API key, Python 3.10+, google-genai, and ffmpeg. Gate 2 leans on Codex's built-in `image_gen` tool for the static frame, so this is a Codex skill first even though it drops into any skills directory. Output is a silent 720x1280 nine-by-sixteen MP4 at 24fps. Solo creators and small video teams producing short vertical content are the audience. The skill itself costs nothing. Google's video generation API is where the money goes, and at five seconds a clip a finished video means a lot of calls, so price that out before you build a workflow around it. The catch: one aesthetic. Halftone paper collage is a strong look and a narrow one, and every clip you make will match every clip anyone else makes with this skill. Output is also silent by design, so audio stays your problem. Useful as one texture in an edit, not as your whole visual language.

Skill is free. Gemini video generation is metered, and five seconds per clip adds up fast.

compass-skills is a set of Markdown skills that help an AI coding agent manage long, multi-session work. It gets the agent to clarify the task, keep a repo-local memory of goals as a kind of task tree, hand off context cleanly between sessions, and follow your collaboration preferences. Everything stays in local plaintext, nothing is uploaded. MIT, free. There is nothing to run and no remote piece; the state sits as plaintext in your repo. It is narrowly aimed at the problem of agents losing the thread across long projects and multiple sessions. It is also very new, a couple of weeks old and mostly one author, so the conventions may shift and longevity is unproven. Early but pointed at a real pain. This is for developers running Claude Code or Codex on long-running projects who keep losing context between sessions and want persistent task memory. Solo or team, it is free. If your work is short and single-session, or you do not want to adopt another agent convention layer, skip it. The catch is maturity. The idea, giving an agent durable memory and clean handoffs, is a real one, but this is an early, single-author project, so bet on the concept more than the specific implementation. If it sticks, great; if it stalls, you have not lost much.

Completely free and open source. Runs entirely local, nothing uploaded.

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.

Chromex is a Chrome side-panel extension that connects your browser to OpenAI's Codex through a local native messaging bridge. Summarize pages, work across tabs and screenshots, edit images, transcribe voice, and run browser-control workflows with visible in-page indicators. MIT licensed. Setup is heavier than a typical extension: clone the repo, `npm install && npm run build`, run `install-native-host.mjs`, then load the unpacked extension at `chrome://extensions`. The architecture (Chrome extension to native host to local bridge to codex app-server) keeps your API key local; raw keys aren't stored in extension storage. Pick this if you live in Chrome, already run Codex, and want one assistant that sees the page you're on. Solo: free, you pay only for Codex tokens. Small teams: same. Large teams or non-Codex shops: skip; this is built around Codex specifically. The catch: Codex-only. Switch to Claude or Gemini for your CLI agent and Chromex doesn't follow. The native bridge is only as polished as the project, which is small and early. For a more mature Chrome AI assistant, Sider and Monica have more features and broader model support.

Free extension. You pay only for Codex tokens.

vibecode-pro-max-kit is an installable bundle of agents, skills, and lifecycle hooks for Claude Code, Cursor, Codex, and similar AI coding environments. The pitch is a spec-driven workflow that pushes you through research, innovate, plan, and execute phases with explicit approval gates instead of letting the agent run free. MIT-licensed, free, installed by curl. Setup is a 30-second curl that drops 12 specialized agents, 31 skills, and hooks into your project's .claude/ directory. The framework's bet is that disciplined phase gates beat raw agent autonomy: you don't get past planning without approving the plan, and you don't get past execution without a spec to check against. Works across any tech stack since it's harness-level, not language-level. For solo developers who keep losing context with vibe-coded agent runs, this is a structured replacement. Small teams adopting it together get a shared coding workflow without having to enforce one manually. Larger orgs will want to read what the agents actually do before standardizing on someone else's prompt library, but the core idea (gate the agent, don't free-run it) is good practice. The catch: this is an opinionated workflow, not a tool. Skip the gates and you've installed 12 agents producing noise. The upstream also changes whenever the maintainer changes their mind, which is its own kind of dependency. If you want to enforce spec-driven coding with AI, this is one way; if you want the agent to be fast and loose, skip it.

Completely free and open source under MIT. Your AI coding tool's subscription is separate.

handdraw-story-video turns a set of 7 to 9 hand-drawn illustrations into a 35 to 45 second vertical video where the line art draws itself in and then fills with color, left to right. It is a real build pipeline you clone and run, not a hosted service. MIT on the code. Setup is the heaviest thing about it. Python 3.10+, Node 18+, FFmpeg, plus HyperFrames and GSAP from npm. You configure a story JSON with your scene data, run a script that extracts line art from your color images, drop the assets into place, then build and render. The render pipeline needs no API keys and no external services, which is unusual in this space right now, though in practice most people will generate the color master images with an image model first. Illustrators and small content teams making short-form vertical video are the fit. The repo root conforms to the Codex Skill structure, so you can install it into your skills directory and trigger it from an agent instead of running the commands yourself. Free at every size, since the only compute is your own machine. The catch: it does exactly one visual effect. Line reveal, then gradual coloring, vertical format, fixed length band. That is a template, and templates go stale fast on the platforms this targets. The MIT license also covers code only, so the fonts, music, and any generated images you feed it carry their own terms.

Free and MIT on the code. Check the fonts, music, and GSAP terms before commercial use.

ai-copywriter is a prompt pack, not software. It's a portable agent "skill", a structured SKILL.md instruction set that teaches any capable LLM to write marketing copy using real copywriting frameworks and then strip out the tells that make text read as AI-generated. It bundles 33 specific fixes drawn from Wikipedia's "Signs of AI writing" list. Because it's instructions rather than code, it runs anywhere an agent runs: Claude, ChatGPT, Manus, whatever you've got. It's versioned, MIT licensed, and credits the upstream humanizer work it builds on, so it's a legit community project rather than a scraped prompt dump. For anyone using an AI assistant to draft landing pages, emails, or ads, it's a free upgrade to your output quality. Install it through the Skills CLI or as a Claude Code plugin and point your agent at it. The catch is exactly what it is: a Markdown file. There's no app, no guarantee, and results still ride entirely on the model you run it against. Treat it as a good starting prompt you'll still edit, not a copywriter in a box.

Free and open source. It's a prompt pack, not a product.

Recall fixes the annoying part of working with Claude Code across sessions: re-explaining your project every time you come back. It captures what happened in a session, the prompts, the responses, the files you touched, the commands you ran, and boils it down to a short summary the agent can read next time to pick up where you left off. MIT licensed, free, and it runs entirely on your machine. The clever bit is that it summarizes locally with classic text-ranking algorithms, TF-IDF and TextRank, so there is no extra LLM call and no token cost for the summary itself. It drops two files in a .recall/ folder: an append-only history log and an auto-generated context digest with your goal, key files, and next steps. It even redacts common secret patterns before writing anything to disk. No setup, works offline. This is a Claude Code plugin, not an MCP server, so it slots into the workflow without extra infrastructure. Solo developers juggling several projects get the most out of it: a 1 to 2K token digest is far cheaper than pasting your whole project history back in, and it works with whatever Claude subscription you already have. The catch is that a TF-IDF summary is compression, not understanding. It surfaces what looks important by word frequency, which is usually enough to orient the agent but occasionally misses the one detail that mattered. Skim the context file before you trust it to have remembered everything.

Completely free and open source. It summarizes locally without an LLM, so it costs no tokens and rides on the Claude subscription you already have.

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.

Guard-skills is a pack of quality gates for AI coding agents. You point your agent at them and they run a second pass over the code it just wrote, catching the specific ways AI-generated code tends to fail: swallowed errors, hardcoded "success" returns, hallucinated APIs, tests that assert nothing. Free and MIT licensed. Five skills cover the bases. One guards general clean code, one guards test quality (mock abuse, duplicate tests, implementation-detail assertions), and one treats your docs as claims and verifies each against the actual code. Two more are specific to WordPress and WooCommerce, handling escaping, sanitization, and money math. Install is a one-liner through the skills CLI, with nothing to host. If you let an AI agent write code, this is a cheap safety net for catching the slop before it ships. It's complementary to your real CI tooling, not a replacement for it. Useful at any team size, though heavier teams will still want proper linters and human review on top. The catch: it's brand new, just a couple of commits in, and tied to agents that support the skills format. Half the pack is WordPress and WooCommerce specific, so a general developer really gets three of the five skills. Worth watching as it grows.

Completely free and open source (MIT).

qiaomu-goal-meta-skill is a skill for Claude Code and Codex that takes a vague request like 'build me an app' and turns it into a structured goal spec: clear success criteria, constraints, safety boundaries, and conditions where the agent should stop and ask. The point is to make an AI agent plan properly before it starts changing things. MIT, free, one command to install. There is nothing to run and no setup beyond adding the skill to your agent. It is narrowly scoped: it generates tight, bounded task specifications, with conservative defaults and pause-on-risk conditions baked in. It is also a young, single-commit project, and the documentation is primarily in Chinese with an English mirror, so set expectations accordingly. This is for people using a goal-style agent who keep getting burned by under-specified prompts and want guardrails between 'I have an idea' and 'the agent is editing files.' Solo or team, it is free. If you already write detailed, bounded task specs by hand, or you do not use a compatible agent, you will not get much from it. The catch is scope and maturity. It does one specific thing, generate disciplined goal specs, and it only helps inside a compatible agent. Treat it as a useful habit-former for agentic work, not a finished framework.

Completely free and open source. One command to install into your agent.

This is a skill for coding agents that turns a JSON spec into a hand-drawn-style architecture diagram, the kind you see in polished technical explainers. Feed it a description of your system and it renders three things at once: an editable Excalidraw file, a static PNG, and an animated GIF with flowing connection lines. It runs locally with Pillow, no external API, no headless browser, and it's MIT licensed. Setup is about as light as it gets. Python and Pillow, no GPU, no Docker, no keys. The AI half runs inside whatever agent you already use, Codex or Claude Code, so the skill itself adds nothing to your bill. It even does a frame-diff check to confirm the GIF actually animates, which is a small touch that shows the author cared. Set your expectations to match the scope. This is a single-author micro-tool with one fixed layout preset and a narrow job: making one specific style of dark-canvas diagram look good. If that's the look you want for a blog post or docs, it's a fast way to get there. If you need flexible diagramming, Excalidraw itself, Mermaid, or D2 give you far more control. Use this when you want the animated explainer aesthetic without hand-placing every box, and nothing more.

Completely free and open source. Runs on your own machine with no added cost.