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 Claude Code setup, open sourced by the Y Combinator CEO: 23 specialist slash commands that act like a virtual team (a CEO who rethinks the product, an eng manager who locks architecture, a designer, a reviewer, a QA lead who opens a real browser, a security officer and a release engineer), plus power tools like /office-hours, /review and /ship. All Markdown, MIT licensed. It's built for Claude Code, with experimental ports to Codex, OpenCode, Cursor, Factory, Kiro and Copilot CLI where its safety hooks are advisory rather than enforced. Install clones it into ~/.claude/skills/gstack and runs a setup script that needs Bun, and it keeps state in ~/.gstack too. Browser QA drives the Aside browser on macOS and falls back to its own Chromium. Solo founders and small teams who want an opinionated, ready-made workflow get the most here, free. Larger teams with their own conventions will mostly mine it for ideas. Telemetry stays off unless you opt in. The catch: it moves fast with no tagged releases, so your setup changes under you every time you pull. The optional GBrain setup can ask for a Supabase access token to create a project for you, so read what you're granting. And it's one person's taste, opinionated by design.
Completely free under MIT. You pay for the Claude Code usage it drives.
**Free:** Everything. MIT licensed, no hosted version, no paid tier. **Self-hosted:** Clones into ~/.claude/skills/gstack. Requires Claude Code, Git and Bun v1.0+ (plus Node.js on Windows). Keeps global state in ~/.gstack. Browser QA uses the Aside browser on macOS 15+ when present, otherwise a bundled Chromium. **Paid:** None. Costs are your Claude Code usage, plus optional third parties: a Codex CLI login for cross-model outside reviews, and Supabase if you set up GBrain.
PPT Master takes a PDF, Word doc, Markdown file, URL or pasted text and hands you back a native, editable PowerPoint: real shapes, text boxes and slide masters, not pictures of slides. A flag adds a second file with data-backed charts and tables you can open with Edit Data. Free, MIT licensed.
It's a skill, not an app: you run it inside Claude Code, Cursor or Codex with Python 3.10+ and one pip install -r requirements.txt. It can also build a template from your brand deck, refill an existing deck, add animations and narrate the speaker notes. The examples gallery holds dozens of single-pass decks, so judge first.
Solo builders and small teams turning reports into decks without a designer save hours. Larger teams with a brand group still want a human pass before anything goes external.
The catch: quality tracks the model, and the first model the README recommends, Kimi K3, comes from a paying sponsor behind an affiliate link. The README also pushes API relays advertising Claude and GPT at as little as 7% of official rates. Pick the model on merit, and keep client documents away from resellers. The optional PDF converter needs AGPL-licensed PyMuPDF.
Free. You pay only for the model tokens and image generation behind it, so choose the model on output quality, not on the README's affiliate links.
**Free:** Everything. MIT licensed, no hosted version, no paid tier. **Self-hosted:** Runs locally inside your AI agent (Claude Code, Cursor, Codex and others). Python 3.10+ plus `pip install -r requirements.txt`; Pandoc only for legacy formats like .doc, .odt and .rtf. The optional PDF input path depends on PyMuPDF, which is AGPL-3.0, worth knowing if you redistribute a bundle. Narration defaults to edge-tts, which sends your speaker notes to Microsoft's online voices. **Paid:** None from the project. Cost is the model you drive it with (tokens for content and layout) plus AI image generation if you use it, such as `gpt-image-2`. Bigger decks cost more. The project is funded by sponsor placements (from $500/month, $1,000/month for the lead slot) and PayPal or Alipay donations.
ECC (formerly Everything Claude Code) is a big bundle of agents, skills, hooks, MCP configs and security tooling you install into Claude Code through the plugin marketplace. It covers code review, security analysis, planning, per-language reviewers, TDD workflows and even video editing. The repo is MIT licensed. It works best in Claude Code, has a supported Codex sync path, and offers capability-limited adapters for Cursor, OpenCode, Gemini, Zed, Copilot and others, so don't assume parity outside Claude. The bundle grows every release, now dozens of agents and a few hundred skills, and slash commands are being phased out in favor of skills. Install only from the official repo, npm packages or ecc.tools: the README warns third-party mirrors may carry malware. The repo is free. ECC Pro, a hosted GitHub App, is $19 per seat a month or $190 a year and adds private-repo analysis, PR-triggered config audits and deeper AgentShield scanning; Enterprise adds SSO and custom policy packs. Solo devs: install the free bundle and keep what you use. Teams that want automatic config audits on private repos: that's what Pro sells. The catch: that much surface area is a lot to audit. Hooks run automatically on editor events, and pulling in agents and skills you didn't ask for makes your setup harder to reason about. One maintainer ships it weekly across several harnesses, so expect churn.
The bundle is free under MIT. ECC Pro, the hosted GitHub App for private repos, is $19 per seat a month.
**Free:** The whole OSS bundle under MIT: agents, skills, hooks, MCP configs, install profiles. The hosted GitHub App's free tier covers public repos only, 10 analyses a month. **Self-hosted:** Nothing to host for the bundle; it installs into Claude Code (plugin ecc@ecc) or via the ecc-universal npm package. **Paid (GitHub App):** Pro $19 per active developer seat per month, or $190 a year, with 50 analyses per seat pooled, private-repo analysis, PR-triggered audits, AgentShield-backed scanning and priority support. Enterprise is contact sales: unlimited analyses, SSO-ready governance, audit logs, custom rules and policy packs, SLA.
Graphify turns a codebase, plus its docs, SQL schemas, PDFs and images, into a knowledge graph your AI coding assistant queries instead of grepping through files. Code is parsed locally with tree-sitter: no LLM, no API key, nothing leaves your machine. The CLI is Apache 2.0 and free.
Install with uv tool install graphifyy (double y; other graphify packages on PyPI aren't theirs), then graphify install adds a /graphify skill to Claude Code, Cursor, Codex and 20+ others. Docs, PDFs and images go through a model, so a docs-heavy repo costs tokens. Code alone costs nothing.
Graphify Labs now sells Graphify Cloud: one always-on graph across repos, with PR review and formal verification. Free covers 3 repos, Pro is $10/month billed yearly, Teams starts at $20/seat billed yearly. Solo and small teams: the free CLI. Many repos: that's the Cloud pitch.
The catch is the moving target. It changed orgs, relicensed from MIT to Apache 2.0 in July, and is now a YC company shipping almost daily. The "80% fewer tokens" headline is about the paid Cloud, not the free CLI.
The local CLI is free under Apache 2.0 and code graphs cost nothing to build. You pay only for the hosted cross-repo graph and PR review: $10/month billed yearly for Pro, or $20/seat/month billed yearly on Teams.
**Free:** The CLI and assistant skill are Apache 2.0 (relicensed from MIT on 2026-07-22; the old MIT text is kept as LICENSE-MIT) with no account. Code-only graphs need no API key and run offline. Graphify Cloud also has a Free plan: one developer, 3 repositories, 25,000 graph nodes per repo, 10 push builds per repo/day, 15 PR reviews per workspace/month and 1 formal verification run/day, no card. Cloud is also free for qualified non-commercial OSS projects under MIT or Apache licenses. **Self-hosted:** The CLI runs on your machine (Python 3.10+, uv or pipx) and writes graph.html, GRAPH_REPORT.md and graph.json; `graphify hook install` rebuilds on commit, and the graph can be served over stdio or HTTP MCP. Optional extras add PDF, Office, video/audio (local faster-whisper), Neo4j and FalkorDB push, Ollama and more. The semantic pass over docs, PDFs and images uses your assistant's session model or an API key (Gemini, Kimi, Claude, OpenAI, DeepSeek, Azure, Bedrock or local Ollama); headless auto-detection checks Gemini first and Kimi second, and Kimi routes to Moonshot AI servers in China, so pass `--backend` explicitly if data residency matters. Self-hosting the full Cloud product (cross-repo graph, PR review, verification) is Enterprise only. **Paid:** Graphify Cloud. Pro: $10/month billed yearly ($120/year) or $15 billed monthly, one developer, unlimited repos, uncapped graph size. Teams: $20/seat/month billed yearly for the first 100 teams, then $28 ($29 and $40 billed monthly), minimum 2 seats, shared graphs and Slack support. Enterprise: custom, self-hosted, SSO/SAML, GitHub Enterprise, licensed per developer seat. Pro and Teams have a two-week trial that requires a card. Pre-seed and seed startups under $1M revenue get 50% off Teams for up to 6 months.
Career-ops turns the AI coding CLI you already use into a job-search filter. Paste a posting and it checks the job is still open, scores it 1 to 5 against your CV in an A-through-H report, then drafts a tailored resume PDF, cover letter and form answers. It never hits Submit. MIT licensed, no paid tier.
Setup is one npx @santifer/career-ops init. Open Claude Code, Codex, OpenCode, Antigravity, Copilot or another CLI in the folder and it interviews you about your CV and targets. The scanner ships with 100+ companies preconfigured, a Go terminal dashboard tracks the pipeline, and an opt-in web UI is still alpha. Your data stays local except what goes to your AI provider.
Solo job seekers: install it. The tool is free; your cost is the model, and free or local models work. One trap: an ANTHROPIC_API_KEY in your shell overrides a Claude Pro or Max login and bills per token. Small teams and larger orgs: not the audience.
The catch: an LLM is rewriting your CV. A check blocks invented numbers, but its own FAQ says it doesn't yet verify job titles or judge rewording, so read every resume before it goes out.
Free and MIT with no paid tier. Your only cost is the model behind your CLI, and free or local models work.
**Free:** Everything. MIT license, no paid tier, no account, no telemetry. The project site says it's community-funded through Open Collective and sponsors, not premium features. **Self-hosted:** Runs locally: `npx @santifer/career-ops init` (or git clone plus `npm install`), then `npx playwright install chromium` for PDF generation. Your CV, reports and tracker are markdown, YAML and TSV files on your machine. Optional plugins (Gmail, Notion, Apify and a community registry) are off by default. **Paid:** Nothing from the project. The cost is the AI engine underneath: a paid CLI plan like Claude Code or Codex, per-token API billing, or $0 on free and local models (Ollama, OpenRouter free models, Antigravity CLI's free tier, or the standalone Gemini API script on Google's free tier).
agentmemory gives your coding agent a memory that survives the session. It hooks into Claude Code, Cursor, Codex, Gemini CLI and more, records what the agent did, and hands the relevant pieces back next time, so you stop re-explaining your stack. It's Apache-2.0, runs on your machine, and it's free.
Setup is one npx -y @agentmemory/agentmemory@latest, which wires your agents and starts a local server plus a pinned iii engine binary. No external database, but it wants Node 20 and four local ports, and native Windows means installing the engine by hand. Default search is keyword-only; EMBEDDING_PROVIDER=local adds free on-device semantic recall.
There is no paid tier. Your only bills are an optional LLM provider and a small server if a team wants shared memory. Solo: free, an easy win. Small teams: free. Larger teams: free, but you're self-supporting a pre-1.0 project.
The catch: the "#1" in the tagline is marketing. The headline 95.2% is retrieval recall on LongMemEval-S, not that benchmark's official QA score, and the project's own report lists MemPalace higher at 96.6%. Compare Mem0, Zep and Letta yourself. Also, the required iii engine is Elastic License 2.0, not Apache.
Free with no paid tier. The only money involved is an optional LLM or embedding provider, and a small VM if a team wants one shared memory server.
**Free:** Everything. Apache-2.0 code, no account and no API key required. You get the local memory server, 54 MCP tools, 12 auto-capture hooks for Claude Code (fewer on other agents), 17 skills and a real-time viewer on port 3113. Keyless mode searches with BM25; `EMBEDDING_PROVIDER=local` adds on-device semantic search with the free all-MiniLM-L6-v2 model. **Self-hosted:** Local by default via `npx -y @agentmemory/agentmemory@latest` (Node.js 20+). It runs a pinned iii-engine v0.22.1 binary (or the `iiidev/iii:0.22.1` Docker image) and uses ports 3111, 3112, 3113 and 49134. For a shared team server there are one-click templates for Fly.io and Railway plus Render and Coolify guides; only port 3111 is published and requests need `AGENTMEMORY_SECRET`. Hosting costs are yours. **Paid:** No paid tier and no hosted cloud from the project. Optional costs only: an LLM provider if you turn on LLM-written compression (`AGENTMEMORY_AUTO_COMPRESS=true`), or a paid embedding provider such as Voyage AI instead of the free local model.
OpenCLI turns websites into terminal commands and lets an AI agent drive your logged-in Chrome. Built-in adapters like opencli hackernews top return tables or JSON, and opencli browser commands let an agent navigate, click, fill forms and extract from any page without an adapter. It's free and Apache 2.0.
Setup is an npm install plus the Browser Bridge Chrome extension, which talks to a local daemon and drives separate Chrome windows that reuse your site logins. Agents get it through skills (npx skills add jackwener/opencli). The adapter list covers 100+ sites with a heavy lean toward Chinese platforms like Bilibili, Zhihu and Xiaohongshu. The optional OpenCLIApp tray app is closed source.
There's no paid tier. You pay only for the LLM tokens your agent spends. Solo and small teams: free, for automating your own accounts. Larger teams: it's per-person tooling, not shared infrastructure; for headless browsers at scale, look at Browserbase.
The catch: an agent in your logged-in browser can do anything you can on every site you're signed into. The extension requests debugger, cookie and all-sites access to do it. It also sheds features fast: the CLI hub and desktop-app automation were cut from the main branch this fall.
Free with no paid tier. The only bill is the LLM tokens your agent spends driving it.
**Free:** Everything: the CLI, the Browser Bridge extension, the built-in adapters, the agent skills and the plugin system, all Apache 2.0. **Self-hosted:** Runs on your own machine. `npm install -g @jackwener/opencli` (Node.js 20.18.1 or later) or OpenCLIApp (macOS Apple Silicon signed and notarized .pkg, Windows x64 unsigned installer; app source not public). Install the extension from the Chrome Web Store or load the unpacked zip from GitHub Releases; it talks to a local daemon on localhost:19825. Video downloads need `yt-dlp`. **Paid:** No paid tier and no hosted version. The only cost is the LLM tokens of whatever agent (Claude Code, Cursor, etc.) drives it.
Prompt Master is a Claude skill that writes prompts for your other AI tools. Ask for "a prompt for Cursor to refactor my auth module" and it identifies the target tool, asks at most three clarifying questions, picks one of 13 templates, and returns one paste-ready prompt. Profiles cover coding agents, chat models, and image, video and voice tools. MIT licensed and free.
Setup is a ZIP upload in Claude.ai's skill settings (the author's recommended path) or a git clone into ~/.claude/skills. Nothing to host. The main file runs about 5,000 words and loads into context whenever the skill fires. With chat history, it prepends a short "Memory Block" of earlier decisions so the new prompt doesn't contradict them.
No paid tier; it runs on the Claude plan or API you already pay for. Solo: free, most useful if you juggle many AI tools. Small and larger teams: free, a decent baseline for briefing agents, not a replacement for your own prompt library.
The catch: the model advice is hardcoded text, only as current as the last commit, and users have already flagged stale guidance. "Zero tokens wasted" is marketing; the skill costs thousands of tokens per run.
Free and MIT. The only cost is Claude usage, and the skill's own ~33KB instruction file rides along on every run.
**Free:** Everything. MIT licensed: SKILL.md plus two reference files (templates and patterns). No account, no paid edition, no hosted service. **Self-hosted:** Nothing to run. Upload the repo ZIP as a skill in Claude.ai (the author's recommended path) or clone it into `~/.claude/skills/prompt-master` for Claude Code. The main SKILL.md is about 33KB (roughly 5,000 words) and loads into Claude's context when the skill triggers. **Paid:** No paid tier from this project. Every run spends usage on whatever Claude plan or API key you already have, and the prompts it writes then run on the target tool's own billing (Cursor, ChatGPT, Midjourney and so on).
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.
Cua gives AI agents a computer of their own: a full macOS or Linux desktop they can click and type through, instead of your screen. The repo bundles Cua Driver (agents operate native apps on macOS, Windows and Linux), Lume (local VMs on Apple Silicon), an SDK and CLI, and Cua Bench for testing agents. Driver, Lume and the SDK are MIT and free.
Setup is a curl | sh installer. The Spaces app needs macOS 26 or later, Lume needs Apple Silicon, and Windows is a preview. You bring the machines: your Mac, a spare Mac mini, or VMs in your own AWS, Google Cloud or Modal account. Cua rents nothing, so it isn't a drop-in for E2B.
Spaces is free for 2 live sessions and 20 relay hours a month; local-network Spaces don't count. Pro is $18/month, Teams $30/seat/month. Solo: free. Small teams: free on one network or over Tailscale; Teams once you want shared machines with roles. Larger teams: wait, SSO hasn't shipped.
The catch: this project deprecates its own floor fast. Five packages are retired (one with known security issues), hosted Cloud Fleets end on October 16, 2026, and Spaces is FSL, not MIT, until each release converts two years out.
Free covers one person on their own machines with up to 2 relayed sessions and 20 relay hours a month. Pro at $18/month ($180/year) lifts that to 5 sessions and 200 hours; Teams at $30/seat/month ($300/seat/year) is for sharing machines with roles, and still lacks SSO.
**Free:** Most of the repo is MIT: Cua Driver (desktop automation for agents on macOS, Windows and Linux, via CLI, MCP or SDKs), Lume (macOS and Linux VMs on Apple Silicon), the `cua` SDK and CLI (Python, TypeScript, Swift, Kotlin) and Cua Bench. The Cua Spaces app is free with no account needed to start: Spaces on every computer you connect, Teleport, sharing a Space with named people, and the hosted relay up to 2 live sessions and 20 relay hours a month. Spaces you reach on your own network skip the relay and don't count. **Self-hosted:** Everything runs on hardware you own or rent: macOS Spaces are Lume VMs, Linux runs on Docker (gVisor sandboxes via `cua sb create`), or VMs in your own AWS, Google Cloud or Modal account, which that provider bills you for. Spaces installs on macOS 26 or later, with Linux and a Windows preview. The Spaces app, cua-spacesd, cua-relay, Keyvault and Teleport are source-available under FSL-1.1-MIT: free to use, modify and self-host, but no competing hosted service, and each release becomes MIT two years after it ships. Cua Driver Bench moved from MIT to FSL on 11 Oct 2026. Remote access normally goes through the cua.ai relay, which is what Pro and Teams meter. A host can also be reached directly over Tailscale or a LAN with no relay and no account, and the relay itself is FSL and self-hostable. **Paid:** Pro is $18/month or $180/year for one person: up to 5 live sessions and 200 relay hours a month (expiring share links and 90-day audit history are listed as coming soon). Teams is $30/seat/month or $300/seat/year, 1 to 100 seats: each seat adds 5 sessions and 200 relay hours to a shared pool, plus shared team machines, roles and device approval. SSO and audit export are not included yet. Going over doesn't cut you off; the app shows an upgrade notice. No trial; yearly plans are refundable within 14 days. You still pay for your own machines, cloud VMs and whatever model API your agent uses. The hosted Cua Cloud Fleets product shuts down 16 Oct 2026.
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.
Browser Harness lets your coding agent (Claude Code, Codex or Cursor) drive your real Chrome, logged in as you: open pages, click, type, read and download. It talks to Chrome over the DevTools Protocol, and when a helper is missing the agent writes one. Free and MIT licensed, from the Browser Use team.
Setup is one prompt pasted into your agent, which installs it with uv and has you tick remote debugging in chrome://inspect. Cursor and other MCP clients use the bundled MCP server. It's no longer a tiny script: it ships interaction guides and a growing library of site-specific skills. In Browser Use's own benchmark, no tool beat it on score and it used the fewest tokens.
Local use costs nothing. Browser Use Cloud is pay-as-you-go at $0.02 per browser-hour plus $5/GB for residential proxies. Solo and small teams: free on your own Chrome. Larger teams running many browsers: the cloud is cheap.
The catch: it gets your whole logged-in browser, and telemetry is on by default. Each run sends the script your agent wrote and up to 20,000 characters of its output to PostHog, which can include page text from your accounts. Run browser-harness telemetry disable first.
Free and MIT on your own Chrome. Cloud browsers are pay-as-you-go at $0.02 per browser-hour plus traffic, with no subscription.
**Free:** The harness is MIT licensed with full local functionality against your own Chrome, plus `browser-harness-mcp` for MCP clients. Telemetry is opt-out (`browser-harness telemetry disable`). **Self-hosted:** Runs on your machine: install with uv (Python 3.11+ per PyPI, the setup prompt asks for 3.12), then tick remote debugging in `chrome://inspect` on Chrome 144+, or point it at any CDP endpoint. No server to run. **Paid:** Browser Use Cloud is optional and has no subscriptions; credits never expire. Cloud browsers cost $0.02/browser-hour, managed residential proxy traffic $5/GB, direct or bring-your-own-proxy egress $0.20/GB. Free accounts get a one-time $1 credit (eligible Google, GitHub or Microsoft signups) and 10 concurrent sessions. Top-ups start at $5; total paid unlocks concurrency ($100 for 50 sessions, $1,000 for 250, $5,000 for 500, $25,000 for 1,000). Enterprise adds custom concurrency, SLAs, HIPAA and zero data retention at custom pricing.
OpenBot is CopilotKit's template for a company AI assistant you run yourself: a ChatGPT-style app where each agent gets its own container with a browser, files and only the tools you grant. Every action passes one gateway that checks your policy, writes an audit row, then acts. The code is MIT. Setup is Docker and Bun, or one published image with Postgres built in. The docs say 2GB of RAM minimum, 4GB recommended, plus about 1GB per browser running at once. Any AG-UI agent plugs in (LangGraph, Mastra, CrewAI or hand-written), and you bring your own model key. Sign-in ships switched off, so turn it on before anyone else can reach it. Here's the paywall: the server refuses to start without CopilotKit Intelligence, their proprietary service for threads and memory. Free hosted covers 1,000 interactions a month per organization; pay as you go is $49/month with 10,000 included. Solo: free. Small teams: free until 1,000 a month, then $49. Larger teams: an Annual contract, custom priced. The catch: MIT code, rented brain. Running Intelligence on your own servers in production is an Enterprise feature. It's also labeled alpha, about ten weeks old, and CopilotKit sells a finished version, Soar, separately.
The OpenBot code is free, but it can't run without CopilotKit Intelligence: free hosted up to 1,000 interactions a month, then $49/month for 10,000, with production self-hosting of Intelligence on Enterprise terms.
**Free:** The OpenBot code is MIT and includes the app, API server, per-agent computers (Chromium, a `/workspace` volume and a browser profile per agent), the policy gateway, audit log, SSO sign-in (Google, Microsoft, Okta, SAML, OIDC) and routines. But the server will not start without a CopilotKit Intelligence URL and key. Intelligence's free hosted plan includes 1,000 interactions per organization per month. The free Developer Edition runs Intelligence locally in Docker for non-production use only, on a renewable 30-day license (a macOS preview). **Self-hosted:** `bash scripts/start.sh` brings up Postgres (with pgvector), the API, a worker and the agent computers; or run the single `ghcr.io/copilotkit/openbot` image with embedded Postgres. Docs list a 2GB RAM / 1 vCPU / 4GB disk minimum, 4GB / 2 vCPU recommended, plus about 1GB per concurrent browser. Optional gVisor isolation for agent computers. Model tokens (OpenAI, Anthropic or Google) are billed separately by your provider. Self-hosting Intelligence itself in production is an Enterprise feature deployed by Helm chart. **Paid:** Intelligence pay as you go is $49/month per organization with 10,000 interactions included, then graduated per-interaction rates; hosted and self-hosted are the same price, no annual commitment, unlimited developers and users. An interaction is one successfully completed agent request; failed requests and dev, staging and test usage are free. SSO for Intelligence comes with Annual. Annual is custom priced and adds offline deployment, custom SSO and up to 24/7 support. CopilotKit also offers paid build-it-for-you services and sells Soar, a ready-made employee assistant powered by OpenBot, separately.
Diagram-design is an agent skill that makes your coding agent draw diagrams a designer wouldn't wince at. Ask in plain words for an architecture sketch, flowchart, sequence diagram, Sankey or Gantt chart, and it picks from more than 40 types and writes one self-contained HTML file with inline SVG. MIT licensed and free.
It's no longer Claude Code only. npx skills add cathrynlavery/diagram-design installs it into Cursor, Codex, Copilot, Gemini CLI, Cline and other skill-aware agents; plugin marketplaces add updates and slash commands. Point it at your website and it pulls your palette and fonts, checks contrast, and every diagram after that matches your brand. It also redraws draw.io, Mermaid and Excalidraw files and exports SVG or PNG.
Solo writers and technical bloggers: install it. Small teams: save a brand profile everyone uses. Larger teams with a design system: test it first, because the style is opinionated on purpose (one accent color, hairlines, no shadows).
The catch: the output is a finished picture, not a source file. Nothing to diff in a pull request, no canvas to drag, and the same prompt can lay out differently twice. For docs that change every sprint, its own README says Mermaid fits better.
Free and MIT. The only cost is the AI agent you already run it in.
**Free:** Everything. MIT licensed skill, templates and scripts. Per its privacy policy there is no server, no accounts, no analytics and no telemetry. **Self-hosted:** Nothing to host. Install with `npx skills add cathrynlavery/diagram-design` or a plugin marketplace (Claude Code, Codex, GitHub Copilot, Factory Droid, Pi). Saved brand profiles in `~/.diagram-design/profiles/` survive updates, but direct edits to the installed `style-guide.md` can be overwritten by package updates, so clone and symlink if you customize it. PNG export needs Playwright and Chromium. Diagrams load fonts from Google Fonts unless you ask for system fonts. **Paid:** No paid tier. It runs inside an AI agent, so the cost is whatever plan or tokens that agent already uses.
GSD Core keeps 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. It runs the heavy research, planning and execution in fresh subagents so your main session stays lean. It's the community continuation of the original Get Shit Done project, MIT licensed and free.
Install is one command: npx @opengsd/gsd-core@latest. It works with Claude Code, OpenCode, Codex, Copilot, Cursor, Windsurf, Antigravity CLI, Kimi CLI and others. The workflow is a new-project command plus a five-step loop: discuss, plan, execute in parallel waves, verify, ship. Releases land every week or two, with a migration path off the deprecated original package.
Solo developers who run long agent sessions and watch quality degrade get the most out of this. Small teams adopting a shared agent workflow can standardize on the same loop. It's free at every scale; the cost is learning the discipline it imposes, which is the point.
The catch: it's methodology wrapped in tooling and only helps if you commit to the loop. Bolt it onto a chaotic workflow and you get chaos with extra steps. A hosted gsd-cloud is announced as coming soon with no pricing yet, so watch whether the free core stays the whole product.
Completely free under MIT. The only cost is the usage of whatever AI assistant you run it with.
**Free:** Everything. MIT licensed, installed with npx @opengsd/gsd-core@latest. **Self-hosted:** Not applicable in the usual sense. It's a command system layered onto your existing AI coding assistant, running locally. **Paid:** None today. You pay only for your assistant's usage. A hosted gsd-cloud for cross-device project state and team visibility is announced as coming soon, with no tiers or prices published.
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.
watermarks-remover strips AI provenance marks: invisible Unicode in text, and C2PA, EXIF and XMP metadata from images, PDFs, Office files, audio and video. Optional add-ons go after the statistical watermarks hidden in AI text and pixels, including SynthID-class marks. Visible stock-photo watermarks are untouched. It ships as an agent skill and Claude Code plugin over a local Python service, MIT licensed and free.
The core is easy: make serve or Docker Compose, and the skill calls it over HTTP. A hook can check every file your agent writes. The add-ons are not: text rewriting needs an LLM backend, and pixel removal wants a GPU and about 10GB of models from an upstream repo with no license file.
There's no paid tier. Solo and small teams: free, and the metadata cleanup is useful hygiene. Larger teams: free, but get legal sign-off before anyone runs the removal add-ons.
The catch: this grew from hygiene into attacks. v0.7.0 added a watermark-stealing module, audio and video watermark removal, and its rewrite benchmark scores human-likeness with Pangram, a commercial AI-text detector. Its own ethics page rules out passing AI text off as human. China bans tools that help others maliciously strip AI labels.
Free and MIT. The real costs are optional: an LLM API for text rewrites, a GPU for pixel removal, and legal review, since two upstream add-ons carry non-commercial or no license at all.
**Free:** Everything, MIT. The core scripts are Python stdlib; exiftool, qpdf and c2patool are optional helpers. Two skills ship: `remove-ai-marks` (service-backed) and `clean-user-facing-text` (text only, self-contained). **Self-hosted:** Run the HTTP service locally (`make serve`, default 127.0.0.1:8765) or via Docker Compose; install the skill for Claude Code, Codex, Cursor, Grok or Cowork, or as a Claude Code plugin with a PostToolUse hook (check mode by default). Optional backends each add cost or license risk: Layer B rewriting needs a local Ollama model or an OpenAI-compatible API you pay for; CtrlRegen pixel removal wants a GPU, about 10GB of model downloads and an HF_TOKEN for gated models, from an upstream repo with no LICENSE (the project treats it as all-rights-reserved); the reverse-SynthID scorer is under a non-commercial Research License; MarkLLM is Apache 2.0. **Paid:** No paid tier. Simple Unmark, an unaffiliated third party, offers a hosted text-only web app built on it.
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 a folder of Markdown into a research wiki your AI agent maintains. Drop papers, articles or transcripts into inbox/, and Claude Code writes linked notes that cite their sources, browsable as a graph in Obsidian. It's a Claude Code plugin plus Agent Skills, MIT licensed and free.
Setup is two claude plugin commands and Python 3.11+; Codex, Gemini, Cursor and others hook in through a script. Version 3 ships 15 skills and 3 read-only agents, can file notes PARA or Zettelkasten style, and applies each change as one transaction that rolls back if a write dies. No telemetry. Windows needs WSL.
Nothing is paywalled. The cost is tokens: every ingest, query and lint runs on your Claude plan or API key. Solo researchers and writers: free, and built for you. Small teams: free, sharing a vault through git. Larger teams: the write lock covers one machine, so treat it as personal.
The catch: PDFs and EPUBs get no built-in text extraction yet, and web pages need a separate fetch step, so research inputs need extra tooling. And an agent writing your notes writes its mistakes confidently. Citations tell you where a sentence came from, not whether it's true.
Free and MIT with nothing gated. Your bill is the agent tokens each ingest, query and lint pass burns on your Claude Code plan or API key.
**Free:** Everything. MIT licensed: all 15 skills (wiki, wiki-ingest, wiki-query, save, wiki-lint plus extensions like autoresearch, canvas and wiki-retrieve), the 3 read-only agents, four filing modes (Generic, LYT, PARA, Zettelkasten), transactional writes with rollback, local BM25 search and the command-line core. No subscription, no account, no tracking. **Self-hosted:** Nothing to host. The vault is plain Markdown on your disk. You need Python 3.11+, Bash, Claude Code (or another Agent Skills host such as Codex, OpenCode, Gemini, ZCode, Cursor or Windsurf), and Obsidian only if you want Graph view, Canvas and Bases. Git is only for checkpoints or sharing. Optional search reranking can use a local Ollama model; remote models and web research stay off until you allow them. Native Windows is read-only; use WSL to write. **Paid:** No paid tier. The real cost is agent tokens on ingest, query and lint runs, billed through your Claude Code plan or whichever host you use. Obsidian itself is free with no commercial license required; its optional Sync is $4 per user per month and Publish $8 per site per month (both billed annually), and this plugin needs neither.
Skill Recorder watches you do a task once and turns it into a skill an AI agent can repeat. It's a free, MIT-licensed Microsoft desktop app: hit record, do the work (narrate if you like), and the GitHub Copilot CLI rebuilds it as an intent plus ordered steps, then writes a reusable SKILL.md or a scheduled automation. There's no installer. Releases are source-only: a pasted command fetches a pinned Node runtime and builds the app on your machine, macOS first, with Windows 11 and Ubuntu supported. Recording and Whisper transcription stay local. Clicking Analyze sends window titles, URLs, clipboard previews, terminal commands, screenshots and narration to GitHub's cloud. Skills install directly into Scout, Microsoft's Autopilot agent, or export for Copilot Cowork or any skill-capable agent. Copilot Studio is still marked coming soon. Solo and small teams: free, with a Copilot plan for the analysis (Pro is $10/month). Larger Microsoft shops: the real bill is Microsoft 365 Copilot at $30/user/month paid yearly, plus usage-based Cowork. The catch: nothing has hit main since 0.7.0 on September 21 and it's still a pre-1.0 experiment. The README also warns against recording passwords or tokens, which rules out a lot of real admin work.
The recorder is free. The bill lives in the Copilot plan behind the analysis and, for Cowork skills, Microsoft 365 Copilot at $30/user/month paid yearly plus usage.
**Free:** The app, MIT licensed, for macOS (primary target), Windows 11 x64/ARM64 and Ubuntu. Recording, frame extraction and optional Whisper narration transcription run on your machine (one-time ~252 MB model download). **Self-hosted:** Releases are source-only. A commit-pinned script downloads a pinned Node.js runtime and builds the app locally; no prebuilt installers. It bundles Copilot CLI 1.0.78, and analysis needs a GitHub account with Copilot access: Free $0 (includes Copilot CLI), Pro $10/user/month with $15 monthly credits, Pro+ $39, Business $19/user/month, Enterprise $39/user/month. CLI usage consumes GitHub AI Credits. **Paid:** No paid tier for the recorder. The cost sits downstream: Cowork skills need Microsoft 365 Copilot, $30.00/user/month paid yearly as the enterprise add-on or $21/user/month paid yearly as the Business add-on ($18 promotional through Dec 31, 2026), and Cowork itself is billed usage-based on top.
Ponytail is a free rules pack that talks your coding agent out of writing code. Before typing, the agent climbs a seven-rung ladder: does this need to exist, is it already in the codebase, the standard library, a native platform feature, an installed dependency, one line, and only then the minimum that works, plus one small test for real logic. MIT licensed, nothing to host. Claude Code and Codex install it as a plugin in two commands. Windsurf, Cline, Aider, Zed and Kiro take a copied rules file without the slash commands. Commands cover intensity (lite, full, ultra), diff review, a whole-repo audit and a tech-debt ledger. Version 5's own benchmark (39 tasks, Opus 5.5, Claude Code) reports 53% less code, 26% lower cost and 41% faster runs than no skill. It's the maintainer's harness, so treat it as directional. Solo and small teams: free. Medium and large teams: free, and worth putting the review command into PRs. The catch: "write less" is a judgment call. A minimalist agent makes quieter mistakes, like reused code that almost fits. Start on lite and read what it declines to build.
Free and MIT licensed, and one of the few free tools that claims to cut a bill you already pay: its own v5 benchmark puts Claude Code sessions about 26% cheaper.
**Free:** All of it, MIT licensed. Every intensity level, all six commands (`/ponytail`, `/ponytail-review`, `/ponytail-audit`, `/ponytail-debt`, `/ponytail-gain`, `/ponytail-help`) and every agent integration. No account, and the lifecycle hooks make no network calls. **Self-hosted:** Nothing to host. Plugin install for Claude Code and Codex, per-agent installs for Copilot CLI, Gemini CLI, OpenCode, Devin CLI, Qoder and others, or a copied rules file (`AGENTS.md`, `.cursor/rules/`, `.windsurf/rules/`, `.clinerules/`, `.kiro/steering/`) for agents without plugin support; rules-file agents get the always-on ruleset but not the commands. The Claude Code and Codex plugins (and Cursor hooks) run small Node.js hooks, so `node` should be on your PATH; without it the skills still work but each hook call prints a `node: command not found` error. Optional default level via `~/.config/ponytail/config.json` or `PONYTAIL_DEFAULT_MODE`. **Paid:** No paid tier. You still pay for the agent and model it runs inside. The v5 benchmark measured mean cost per Claude Code session at $0.200 with no skill and $0.142 with Ponytail 5 (list price). The maintainer runs an email waitlist at ponytail.dev/soon for an unnamed upcoming product; nothing is priced yet.
Cloudflare's security-audit skill turns a coding agent into a code auditor. A skill is a packaged set of instructions an AI agent loads for one job. This one maps your app's trust boundaries, sends isolated hunter agents through a coverage plan, then hands every candidate to a fresh agent that tries to disprove it before anything gets reported. It's the seed of Cloudflare's own fleet scanner, MIT licensed and free.
Install is one command, npx skills add, then ask your agent to audit the repo. You need an agent that runs parallel sub-agents, plus Node for the bundled validators. It only executes the target's code inside a network-off sandbox. Without one, leads stay marked needs_validation.
There's no paid tier. The bill is model tokens, and a full run spawns a lot of agents. Solo devs and small teams: free and a strong first pass. Larger teams: one input next to a human review.
The catch: one run isn't enough. Cloudflare says a single run finds about half of what repeated runs catch, skewed toward simpler bugs. And its prompts don't tell agents to ignore instructions planted in the code they read, so a hostile repo could steer the audit.
Free and MIT licensed. The real cost is model tokens across many sub-agents, and since one run finds about half of what repeated runs do, budget for several.
**Free:** MIT licensed with no license fee. Install through the Skills CLI (`npx skills add`, pointed at the repo with `--skill security-audit`) and run as many audits as you want. Security questions get a lighter guidance mode; the full six-phase workflow runs when you ask for a codebase audit or pen-test. **Self-hosted:** Runs inside your own coding agent, so there's no service to operate. Requirements: an agent whose model supports tool use and parallel sub-agents, and Node.js for the zero-dependency findings and coverage-ledger validators. Confirming findings by running the target's code needs an OS-enforced sandbox (no external network, allowlisted environment, resource limits); without it the skill stays read-only and leaves leads as needs_validation. Output defaults to `~/security-audit-skill/<repo-name>/run-<N>`. **Paid:** No paid tier for the skill. Your spend is model tokens, and it scales with agent count: each coverage unit is roughly one hunter assignment and each surviving candidate one or two verifier assignments. You can set a budget as a maximum number of agent invocations. Multiple runs are additive, and Cloudflare reports a single run finds roughly half of what repeated runs find, so plan for more than one.
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.
Anatomy makes Claude explain a technical idea by drawing a machine that does it. Ask how a token-bucket rate limiter works and you get an interactive isometric figure built from dozens of shaded SVG parts, with live numbers from the same model that moves them. WebGL handles fire, water and glow; a beta 3D mode turns parts in true depth. MIT, free, no API keys.
Install is one npx skills add line, and it also loads in Codex, OpenCode, Antigravity and MiniMax Code. The kit uses only Node's built-in modules, but the self-checks need Node 20.10+ and Chrome, driven headless to screenshot and audit every joint. Eight examples ship in the repo, from a dial gauge to a Raptor engine. Solo writers, devrel folks and small docs teams: free. Larger teams with designers will still hand final art to an illustrator.
The catch is time, which means tokens. The author publishes his own numbers: a watch movement took 1 hour 54 minutes of Claude working, the Raptor engine 10 hours 33 minutes, a turbofan 14 hours. The skill demands at least 40 parts per figure and won't trade detail for speed unless you ask. Ask for a quick figure first.
Free and MIT, but a detailed figure can burn hours of agent time; the author's own builds ran from about 2 to 14 hours.
**Free:** The skill, the drawing kit, the audit and capture scripts, and eight example figures are MIT. No API keys and nothing to `npm install`. **Self-hosted:** Runs locally inside Claude Code, Codex, OpenCode, Antigravity or MiniMax Code. Needs Node.js 20.10+ for builds and checks, Chrome or Chromium for the headless screenshot and audit scripts, and React 18+ only if you want component output. The skills CLI copies the whole repo, examples included, about 10 MB. A separate MIT npm package, anatomy-figures, ships the author's finished figures as React components. **Paid:** No paid tier. The cost is agent time: the author reports 1 h 54 min of Claude's active time for a watch movement, 10 h 33 min for the Raptor engine and 14 h for a turbofan, review rounds included. Budget your agent plan or API spend accordingly.
Engram is a memory layer for AI coding agents. Your agent forgets everything when a session ends; Engram stores the bug fixes, decisions and conventions it learns in a local SQLite file with full-text search, then hands them back next session. It works with Claude Code, Codex, Cursor and any other agent that speaks MCP (the plug-in standard agents use to call outside tools). MIT licensed and free.
Setup is easy: brew install gentleman-programming/tap/engram, then engram setup claude-code (or your agent). One Go binary, no Node, Python or Docker. Sharing across machines works through Git sync, or Engram Cloud, which is a server you host yourself on Docker and Postgres, not a paid service.
There's no paid tier anywhere. Solo: free, five minutes. Small teams: free with Git sync or one self-hosted Cloud box. Larger teams: free, but someone owns the server, tokens and upgrades.
The catch: memory is only as good as what the agent chooses to save, and junk memories pollute later sessions. "Personal" memories are a search filter, not a privacy wall: enroll a project for sync and they go to everyone with access. Releases land almost daily, so pin versions. claude-mem is the closest alternative.
Free at every size. Team sharing means running your own Engram Cloud server on Docker and Postgres; there is no hosted plan to buy.
**Free:** Everything. The CLI, MCP server, HTTP API, terminal UI, Git sync and Engram Cloud are all in the MIT-licensed repo. Memory lives in a single local SQLite file (`~/.engram/engram.db`). **Self-hosted:** Locally it is one Go binary via Homebrew or GitHub Releases, with zero infrastructure. Engram Cloud, the optional team sync server with a browser dashboard, is self-hosted only: `docker compose` with Postgres, an official GHCR image for linux/amd64 and arm64, on your own VPS, Dokploy, Coolify or Portainer. You own tokens, backups and upgrades. **Paid:** No paid tier and no hosted service. The only real cost is whatever AI coding agent you already pay for.
Baoyu-design takes the design engine behind Anthropic's claude.ai/design and runs it inside the coding agent you already use. Ask Claude Code, Cursor or Codex for a mockup, prototype, wireframe, landing page or deck, and it writes self-contained HTML into your repo. MIT-licensed and free.
Version 2.0 shipped this week as five skills. The original makes HTML designs; four new ones port claude.ai's slides, design canvas, design system and dashboard formats, each with a local editor so you and the agent take turns. Install is one npx skills add JimLiu/baoyu-design; the editors need Node 20 or newer. Exports cover PDF, editable PowerPoint, and handoff to Figma or Canva.
The bill is the model: it's tuned for Claude Opus 5.5, so free assumes you already pay for an agent. Solo and small teams: free, install it and go. Larger teams: good for first drafts, but it won't replace Figma for collaboration, and v0 wins when you want a deployed app.
The catch is provenance. The README says it repackages Anthropic's Claude Design nearly word for word, unaffiliated and unendorsed. MIT covers Jim Liu's packaging, not Anthropic's prompts. Expect churn too: four releases landed in one day.
Free and MIT. Your spend is the coding agent and model it drives, and it's tuned for Claude Opus 5.5.
**Free:** Everything in the repo under MIT: the baoyu-design skill (HTML mockups, prototypes, wireframes, landing pages, decks) plus the claude-slides, claude-design, claude-design-system and claude-dashboard skills with their local editors. **Self-hosted:** Nothing to host. `npx skills add JimLiu/baoyu-design` installs it into Claude Code, Cursor, Codex and other agents the skills CLI supports. The local editors need Node 20+ (the dashboard needs Node 22+), and editable PPTX export needs a one-time Playwright and Chromium build. **Paid:** No paid tier. The real cost is the AI coding agent and model underneath; the README recommends Claude Opus 5.5 and says it still works on other capable models.
video-shotcraft is a skill for Claude Code or Codex that turns your coding agent into a motion-design studio. Ask for a product video and it storyboards, animates real page captures with 2.5D camera moves, syncs cuts to a beat and adds sound design, then renders everything locally through Remotion. No AI video APIs, no API keys, no per-clip cost. Apache 2.0.
It installs with npx skills add and runs inside the agent and Remotion toolchain you already have. After delivery it opens a local browser workbench for tweaking the result, and it can export a project to JianYing (CapCut's Chinese edition), tested on macOS only. Headless rendering on Linux needs a Chrome headless binary and low concurrency on small machines.
The assets are the value: 157 shot recipes, a couple hundred Remotion motion demos and 149 sound effects, so the agent isn't improvising from scratch. Solo developers and companies of up to three people pay nothing. At four or more, Remotion requires a company license, starting at $25 a month per seat. The skill itself stays free.
The catch: the skill tells your agent to describe the finished video as free for commercial use, but the author's own attribution file lists five bundled sound effects whose source couldn't be traced and says to confirm them before commercial use. Swap those out before client work. Only one finished template (Ink Press) ships so far, and the skill nudges you to tag the author on social media when it's done.
The skill is free. Remotion is free up to 3 employees, then $25 per seat per month.
**Free:** The whole skill, Apache 2.0: 157 shot recipes, Remotion demo components, the Ink Press template (9 color themes), 149 sound effects and 5 music tracks, plus the local workbench editor. No AI video APIs and no API keys; everything renders locally. **Self-hosted:** Installs into Claude Code or Codex with `npx skills add Vincentwei1021/video-shotcraft`. Renders through Remotion on your machine. Headless Linux needs chrome-headless-shell and `--concurrency=1` on small boxes. JianYing export needs ffmpeg and is only verified on macOS. **Paid:** Nothing from the skill. Remotion's own license is free for individuals, non-profits and for-profit companies with up to 3 employees. Larger companies need a Remotion Company License: $25/month per seat (Creators), or $0.01 per render with a $100/month minimum (Automators); Enterprise starts at $500/month. **Licensing fine print:** Five bundled sound effects are marked in the repo's own ATTRIBUTION.md as untraceable, to be confirmed before commercial use.
Universal Modder turns Claude Code (or Codex, Gemini CLI, Cursor and others) into a game-modding agent. It bundles skills for engine fingerprinting, reverse-engineering playbooks, asset generation, in-game testing and packaging, plus a Python CLI that scans your Steam, Epic and Xbox installs and ranks the routes for modding each game. MIT licensed. Install it as a Claude Code plugin; you also need Git, Python 3.10+ and ffmpeg, plus Blender for 3D-to-sprite renders. Asset generation runs through fal's hosted models with a fal API key, or a local ComfyUI server for images without one. It asks before driving your mouse and keyboard, installing loaders into game folders, or publishing. The plugin is free; the art isn't. fal bills per generation, about $0.08 per image on the default editing model, with 3D, sound and voice priced separately, and the skill tells the agent to warn you before running more than about 20 generations. Solo hobbyists modding games they own are the audience. The author works at fal, which the README doesn't mention. The catch: the safety rules (no injecting into online games with anti-cheat, no cheats against other players, hands off DRM) are instructions to the agent, not enforcement. Its scope covers multiplayer games and servers you host, and the shared knowledge base already includes WoW private-server notes. It launched in late September 2026 with no versioned releases yet.
Free under MIT, but asset generation runs on fal's pay-per-use models, and the author works at fal.
**Free:** The plugin, skills, CLI and knowledge base are MIT. **Self-hosted:** Runs on your machine alongside your agent. Needs Git, Python 3.10+, ffmpeg, and Blender for 3D renders. Input automation is Windows-centric (PowerShell). A local ComfyUI server can replace fal for image generation. **Paid:** Asset generation through fal is pay per use: about $0.08 per image on the default edit model (nano-banana-2), $0.002 per second of sound effects, $0.10 per 1,000 characters of voice, with 3D and video models priced per unit. fal's pricing page notes resolution, duration and quality change the final cost. Your agent subscription is a separate cost.
Day Trader Skill is 11 Claude skills that walk a day trade end to end: scan charts for setups, pull the news, time the entry, set the stop and target, size the position, check your risk limits, and hand a ticket to your broker. The Python is standard library only and reads free public data from Yahoo Finance, SEC EDGAR, Nasdaq Trader and the House Clerk. MIT, no API key. Install it as a Claude Code plugin, add your name and email for SEC requests, done. The standout is the Time Machine: it replays the rest of the session 10,000 times from the stock's own recent bars and gives you the odds before you risk a dollar. Orders are optional and go through Alpaca's official MCP server (paper account by default, and paper trading is free) or the Interactive Brokers connector. The skill's script never sees your keys. Solo traders: free. Not a team tool. The catch is day trading itself. The author's own fine print says most day traders lose money. Yahoo's chart endpoint is unofficial and can lag, and the simulation only knows the last 60 days. One commit, no updates since. Paper trade first.
Free to run on free public data, and paper trading through Alpaca costs nothing. The real cost is trading losses, which the author's own fine print warns about.
**Free:** All 11 skills and their Python tools are MIT. Data comes from free public sources: Yahoo Finance's chart and RSS endpoints, Nasdaq Trader symbol lists, SEC EDGAR and the House Clerk's disclosure filings. Nothing to pip install. **Self-hosted:** Runs locally in Claude Code with Python 3.8 or newer. Everything is written to a `trader/` folder in your project. Order placement is optional: the broker skill only builds and logs tickets, and Claude sends approved orders through Alpaca's official MCP server (paper account by default) or the Interactive Brokers connector, with your keys typed into Claude Desktop's config, never the chat. **Paid:** No paid tier. Alpaca paper trading is free. Live trading costs and data limits depend on your broker; you also pay for Claude itself.
Answer Me With HTML turns your coding agent's long answers into a one-page HTML explainer with auto-laid-out flowcharts, timelines, trees and tables, or into a narrated explainer video. The agent writes a Markdown draft and a bundled Node script renders it, so the agent never hand-writes HTML. MIT licensed, needs Node 20+.
Install it as a Claude Code plugin or with npx skills add. There's nothing to host: pages land in a folder in your home directory and open in your browser. The only network calls are a weekly version check against GitHub and ElevenLabs narration if you set an API key; otherwise videos use your Mac's built-in voice. No telemetry.
This suits people who learn better from a diagram than a wall of terminal text: architecture walkthroughs, comparisons, plan reviews. Developers who live in SSH sessions, or want answers searchable in the transcript, should skip it, because the reply shrinks to two or three lines plus a file link.
The catch: it's written to fire without being asked, even when plain text would do, and every page pops a browser window by default. Turn off auto-open in its config or tell it to run only when you ask, or it gets noisy fast. It launched in October 2026 and ships several releases a day.
Completely free under MIT. Only optional ElevenLabs narration costs money.
**Free:** Everything. MIT skill plus a bundled Node CLI. **Self-hosted:** Nothing to host. Pages are written to ~/.answer-me-with-html/pages/. MP4 export needs Chrome, ffmpeg and Node 22+. **Paid:** None from the project. Optional ElevenLabs narration for videos uses your own ElevenLabs API key and is billed by ElevenLabs; without it the tool uses macOS system voices or subtitles only.
huashu-art-motion teaches a coding agent to animate paintings in code. Ask for a Van Gogh clip and it paints the scene on a canvas, makes the brushstrokes move, and renders an MP4 through headless Chromium. It ships 36 art-style recipe cards with 35 ready scene files, plus 9 explainer grammars modeled on Kurzgesagt, Vox, 3Blue1Brown and whiteboard videos. MIT and free.
Install is one npx skills add line, but rendering needs uv, ffmpeg and Playwright Chromium. A QA script scores motion and smoothness, and the delivery script refuses to export a film that's basically a slideshow. Cloned voices bill your own ByteDance Volcengine account; macOS system voices cost nothing. Solo creators and small teams making explainer clips: free, plus your agent's usage. Studios doing client work: stick with After Effects or Remotion.
The catch: the skill itself is written in Chinese. SKILL.md and the recipe cards are Chinese: your agent reads them fine, you won't when a render breaks. The showcase also leans on characters nobody here owns (a Super Mario level, a Rick and Morty style, Anthropic's mascot), and the author's own character art is carved out of the MIT grant. Restyle before you publish anything commercial.
Free and MIT; the only bills are your coding agent's usage and, if you want a cloned voice, your own Volcengine account.
**Free:** Everything in the repo is MIT: 36 art-style recipe cards, 35 Canvas scene files, 9 explainer-video grammar cards with 8 parameterized clips, the breakdown, QA and delivery scripts. No account, no key needed for basic code-only animation. **Self-hosted:** Runs locally inside your coding agent (Claude Code, Codex and Kimi Code CLI are the tested install targets). Rendering needs uv, ffmpeg and Playwright Chromium. Exceptions to MIT: bundled stroke data keeps the Arphic Public License, fonts keep SIL OFL, and the author's cartoon character art plus the Clawd fan demo are demo-only and not MIT. **Paid:** No paid tier. Real costs are your agent's subscription or API usage, and optionally a ByteDance Volcengine account for voice cloning (billed by Volcengine, not priced in the repo). Image generation for human characters goes through whatever image tool your agent already has.
logo-design-skill teaches an AI agent to design logos the way a studio does: brief first, about three concepts, then it stops and waits for you to pick a direction before refining. It works in Claude Code, Claude.ai, Gemini CLI and Codex, and ships 14 reference guides (principles, mark types, color, type, SVG construction), nine Python scripts and a library of 1,432 real-world logos to study. MIT licensed. Install is a Claude Code plugin command, or a zip upload to Claude.ai (a lite version drops the logo library). The scripts use only Python's standard library: they audit an SVG for production problems, build test sheets down to favicon size, render client presentation boards and export the full icon set. No network calls. It works best with a model that can see images, because it checks its own drafts. Founders and small teams who need a first logo and would otherwise reach for Looka or Canva's logo maker should try this first. It costs nothing beyond your agent plan. A brand with real stakes still deserves a designer; use this to write them a sharper brief. The catch: output is only as good as your model's SVG skills, and every example in the README is the author's own run on made-up brands. The 1,432 reference logos are other companies' trademarks, included for study and outside the MIT license, so don't ship anything that leans too close to one. It's days old, from an author with no prior track record.
Free. The cost is your agent usage and a model that can draw decent SVG.
**Free:** MIT licensed skill text, scripts, templates and catalog data. The 1,432 bundled logo SVGs are third-party trademarks included for study only; the MIT license does not cover them. **Self-hosted:** Runs inside your agent: Claude Code plugin, Claude.ai/Desktop zip upload (4.0MB full, 0.3MB lite without the logo library), or copied into Gemini CLI or Codex skills folders. Scripts need Python 3.8+ with no required packages; PNG rendering uses cairosvg, rsvg-convert, Inkscape, headless Chromium or macOS Quick Look, whichever is available. **Paid:** None. The only cost is your agent or model usage. For comparison, the usual alternatives are paid logo generators or a designer.
dbskill is a pack of 34 Chinese-language business skills for AI agents from the creator dontbesilent. Not coding skills: diagnosing why a business is stuck, finding competitors worth copying, planning content, writing short-video titles and hooks, checking scripts for platform moderation risk. The method comes from 16,152 of the author's public posts.
Install is one npx skills add command or the Claude Code plugin marketplace, and it runs in Claude Code, Codex, Doubao, WorkBuddy and other skill-aware agents. A /dbs router picks the right skill for you. Nothing to host. Everything is in Chinese, so answers come back in Chinese.
Most skills cost only your agent's tokens. Video extraction is the exception: it needs paid TikHub and Qingdou API credits and walks you through buying them. The README also links a paid Q&A group with the author at ¥299 (about $42). Solo creators: free for personal use. Small teams and up: get the author's sign-off first. Engineering teams: skip it.
The catch is the license. CC BY-NC 4.0 means non-commercial only, and the README says commercial use needs the author's authorization. A business toolkit you can't freely use in your business is an odd shape. Read the terms first.
Free for personal, non-commercial use; commercial use needs the author's authorization at an unpublished price. The video-extract skill only works with paid TikHub or Qingdou API credits.
**Free:** All 34 skills, downloadable from GitHub under CC BY-NC 4.0: free for personal study, research and non-commercial use with attribution. No account and no dbskill API key for the core skills. **Self-hosted:** Nothing to host. The skills install as local files into your agent with `npx -y skills add dontbesilent2025/dbskill -g --all` (Vercel's skills CLI) or through the Claude Code plugin marketplace. Saved sessions live in `~/.dbs/` on your machine, and a version check calls GitHub at most once every 24 hours. **Paid:** No paid tier for the skills themselves. Commercial use needs the author's authorization, with no published price. The video-extract skill only works with paid credits from TikHub (post data) and Qingdou (transcripts); the skill states dbskill has no affiliation with either. The author also sells a paid Q&A WeChat group for ¥299 (about $42), with no time limit. Your agent's model tokens are the running cost.
phone-harness hands an AI agent your phone. Claude Code, Codex or any shell-capable agent gets eyes (on-screen text with tap coordinates) and hands (taps, swipes, typing) on a real iPhone or Android, with no jailbreak and nothing installed on the phone. MIT licensed and free.
iPhone runs through the Mac's iPhone Mirroring window with Apple's Vision OCR, so it needs macOS Sequoia, and the window stays in front unless you opt into an experimental background mode. Android goes over adb from macOS, Linux or Windows and reads the accessibility tree. iPhone Mirroring still isn't offered in the EU, so EU users get Android or cloud.
No spare phone? Phone Harness Cloud rents hosted iPhones and Androids at 5 cents a minute per phone, with $5 of promo credit to start; dedicated phones are custom-priced. Solo tinkerers: free on your own device. Teams doing real mobile testing: Appium, Maestro and BrowserStack remain the serious answers.
The catch: you're giving an LLM your logged-in phone, and telemetry is on by default. It sends your script, helper-call arguments (including text you type) and up to 20,000 characters of output to PostHog. Run phone-harness config set telemetry false first.
Free on a phone you own. Cloud phones are 5 cents a minute per phone (about $3 an hour), with $5 of starter credit.
**Free:** The harness itself, MIT licensed, on PyPI as `phone-harness`. Driving your own iPhone or Android costs nothing, and a cloud account needs no card. **Self-hosted:** Runs locally as a uv or pip tool. iPhone: macOS Sequoia or later with iPhone Mirroring paired, plus Accessibility and Screen Recording permissions; iPhone Mirroring is not available in the EU. Android: adb on macOS, Linux or Windows, over USB or Wi-Fi (Android 11+). Anonymous-labelled telemetry is on by default and includes the script text, helper-call arguments and up to 20,000 characters of output; turn it off with `phone-harness config set telemetry false`. **Paid:** Phone Harness Cloud (open beta): hosted iPhones and Androids at $0.05 per minute per phone, billed per minute, boot time free. New accounts get $5 of promotional credit (about 100 minutes, non-refundable). Top-ups are $5 to $200 by card and purchased credit doesn't expire. Dedicated phones (reserved around the clock, multiple profiles per phone, your choice of proxies, invoicing) are custom-priced via a demo call.
Replica is eleven Claude skills that walk an agent through rebuilding someone else's app: map its screens and flows, plan the stack, build, test, score against the original, rename and ship. The standout is the Entrepreneur skill, which ranks what users complain about in real reviews so your version fixes it. MIT, no signup, no API key.
Install is copying eleven folders into ~/.claude/skills/. The six helper scripts are standard-library Python with no network imports: a screenshot layout diff, a parity score, a review ranker that drops unlinked quotes, and a sweep that blocks deploy while the original's name or colors remain. The real cost is agent time; the author says a booking tool is weeks. Solo builders and small teams: a decent competitor-build checklist. Larger teams already have a product process.
The catch: "clone any app" is the headline, and the fine print walks it back to features and flows, clean-room style: no scraping behind logins, trademark checks, a lawyer before launch. Good guardrails, but they're prompt instructions, not enforcement, and the legal risk is yours. It's also one commit with five unmerged PRs, one reporting the plugin install loads none of the skills. Copy the folders.
Free and MIT; the bill is agent time on a multi-week build, not the skills.
**Free:** All eleven skills and six helper scripts are MIT. No signup, no API key, nothing to connect. **Self-hosted:** Copy the replica-* folders into `~/.claude/skills/` or a project's `.claude/skills/`. The scripts need Python 3.8+ and nothing from pip. A plugin-marketplace install is documented, but an open PR reports Claude Code rejects the plugin's skills path, so copying folders is the reliable route. Any single SKILL.md can be pasted into a chat without Claude Code, minus the scripts. **Paid:** No paid tier in the repo. The cost is your agent's usage across a build the author sizes at weeks for a booking app, plus whatever stack you deploy (the worked example picks Next.js, Postgres, Stripe and Resend). The author's site sells custom agent builds starting at $10,000 to $15,000, which is consulting, not an upsell for this skill.
iPhone Use lets Codex operate your real iPhone over USB. Describe a task in plain language and the agent opens apps, reads the screen, taps, scrolls and types, while a sidebar shows the phone live. Under the hood it's Appium's WebDriverAgent on the phone, driven by a local MCP server (the plug-in protocol AI assistants use to call tools), with no separate Appium server. Free, MIT.
Setup is the hard part. You need a Mac with full Xcode (Command Line Tools won't do), Python, Node.js, Developer Mode on the iPhone, and an Apple account in Xcode to sign the WebDriverAgent runner. A free Personal Team works, but Apple expires those profiles after 7 days, so plan on rebuilding weekly. The setup skill walks Codex through it; Apple login, trust prompts and unlocking stay with you.
Solo: free, and it works with Codex, WorkBuddy or Doubao Work. Teams doing app QA: use a proper Appium setup or a real-device cloud like BrowserStack; this is built for one person's phone.
The catch: the Codex version sends anonymous usage analytics to the author's PostHog project by default. Phone images and typed text stay local, per the docs, and IPHONE_USE_ANALYTICS=0 turns it off.
Free and MIT. The real costs are the agent plan driving it and, on a free Apple account, re-signing the on-phone runner every 7 days.
**Free:** MIT. The Codex plugin, local MCP server, setup and usage skills, and the live-screen widget are all in the repo, plus adapters for WorkBuddy and Doubao Work. No paid tier. The Codex version sends anonymous usage analytics to the author's PostHog project by default (opt out with `IPHONE_USE_ANALYTICS=0` or `DO_NOT_TRACK=1`); the WorkBuddy and Doubao adapters ship with analytics off. **Self-hosted:** Everything runs on your Mac: macOS, full Xcode with first-launch setup done, Python 3.9+, Node.js 20.19+, 22.12+ or 24+ with npm 10+, and an iPhone over USB with Developer Mode on. The phone runs Appium's WebDriverAgent, pinned to a verified 16.14.0 commit, which you sign with your own Apple account and team. A free Personal Team is limited to 3 apps/devices and its profiles expire 7 days after signing, so the runner needs a rebuild and reinstall. **Paid:** No paid tier from the project. You pay for whichever agent drives it (Codex, WorkBuddy or Doubao Work under their own plans). A paid Apple developer team stretches signing past the 7-day free-profile limit.
fast-jev-compaction changes what happens when a long Claude Code session runs out of room. The built-in behavior summarizes old conversation, which loses detail. This plugin asks Jev, a decision model from TypeSafe AI, which old tool calls and outputs are stale, deletes only those, and keeps every user and assistant message word for word. MIT licensed. Install goes through the Claude Code plugin marketplace, straight from the repo. It needs an environment flag for function hooks, which the README calls an early-access Claude Code feature, plus a TypeSafe API key. Jev bills $0.042 per million input tokens and is waitlisted. When Jev errors out or does not cut enough, the plugin falls back to the normal summary. Solo developers living in long Claude Code sessions are the audience, once they have Jev access. Teams should think harder, because the plugin sends your session transcript to TypeSafe for scoring. The catch: do not run the npm install line in the README. As of September 21, 2026, the fast-jev-compaction name on npm belongs to a different account publishing its own fork with extra command line tools. Nothing in it looked malicious on a static read, but it is not the author's package. The marketplace path pulls from the repo and is unaffected. Token sizes are also estimated from character counts, and users report the hooks not loading on some Claude Code versions.
Free MIT plugin. Each compaction costs a fraction of a cent in Jev API calls, and Jev access is waitlisted.
**Free:** The MIT plugin and TypeScript library. **Self-hosted:** It runs inside your local Claude Code, but the scoring happens on TypeSafe AI's hosted API. There is no local or open-model mode. **Paid:** Nothing to the author. Each compaction sends the session state to Jev, which bills $0.042 per million input tokens with free output. Access is waitlisted. You also need your normal Claude Code subscription or API key.
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 an agent skill that builds scroll-driven landing pages: video that scrubs as you scroll, sections that pin, headlines that assemble line by line. It installs as a Claude Code plugin and also works in Codex or any agent that can edit files, run commands and drive a browser. MIT licensed and free. The value is the rulebook: eight page grammars that exclude each other, a typography and spacing floor, a refuse list (gradient text, fake dashboards, AI-purple gradients), and a fingerprint gate that makes each build differ from your earlier ones on at least 4 of 6 dimensions. A headless browser then checks the finished page for dead scroll and weak contrast. Setup needs Node 18+, a full ffmpeg build and playwright-core. Your own photos and footage cost nothing. Generated images and video bill kie.ai credits on your own key, around 520 for a modest page. Solo builders and small studios: free. Teams: point it at a brand kit and your rules win. The catch: the author says it has only ever been run on Windows. It's also one person's taste turned into hard rules, and it will argue with you about your page.
Free and MIT licensed, and free to run if you bring your own photos and footage. Generated video bills kie.ai credits on your key, around 520 for a modest page and about 2,000 for a ten-leg flight at published rates.
**Free:** The whole skill, MIT licensed. Install it as a Claude Code plugin (`/plugin marketplace add nateherkai/scroll-craft`, then `/plugin install nateherk-design`) or copy the skill folder into Codex or another agent. Building from your own photos and footage needs no API key and no spend. **Self-hosted:** Runs locally inside your coding agent. You supply Node 18+, a full ffmpeg build (stripped builds missing filters are a common failure, the `doctor` script checks for this) and `playwright-core` plus Chrome for the verification pass. The local preview server binds to 127.0.0.1 by default since 0.3.1. **Paid:** No paid tier from the project. Two outside costs: your coding agent (a Claude or Codex subscription or API usage), and optional kie.ai credits if you want generated assets. The author cites published rates of 28 credits per still and 160 credits per 5-second clip, about 520 credits for a modest six-act page and closer to 2,000 for a ten-leg continuous-world flight.
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.