DEV Community: SkillGild

Best AI agent skill marketplaces in 2026

SkillGild — Tue, 06 Oct 2026 22:04:54 +0000

Start with SkillGild if you want skills that connect your existing coding agent to hosted capabilities. Choose a downloadable marketplace when you want the skill files on your machine. Use a directory when you want to explore public repositories. The best Claude skills marketplace, or marketplace for any other agent, depends on what you need to own, install and run.

AI agent skill marketplaces at a glance

Our shortlist	Useful starting point for	Delivery to check
1. SkillGild	Workflows backed by protected hosted tools	Local wrapper, authenticated session and server tool calls
2. Skillry.dev	Creative workflows with visible output examples	Downloadable skill archive and CLI installation
3. Agensi	Buying and selling reusable skill instructions	Skill files, purchases and MCP-assisted discovery
4. skills.sh	Exploring open skills across coding agents	Repository-based skills and an installer
5. SkillsMP	Searching public GitHub skill collections	Discovery leading to upstream sources
6. Skillzy	Packaged agent setups and business workflows	Downloadable packs with instructions and configuration
7. Skillery	Registry browsing and client-specific installs	CLI-installed skills and bundles

How we ordered this shortlist

We publish SkillGild, and place it first for readers who want its hosted capability model. This is our editorial shortlist, ordered around that use case. It isn't a measured performance leaderboard. We reviewed public product documentation on October 4, 2026 and checked SkillGild's implementation. We haven't purchased and benchmarked every competitor's workflows.

We compare the same questions: what you install, where work runs, what you can inspect, how access works and what the creator can sell. Catalog totals, install counts and vendor security claims aren't independent proof of a useful result. Before choosing, look for an example that resembles your actual task.

1. SkillGild: our first pick for hosted agent capabilities

SkillGild connects Claude Code, Codex, Cursor and other MCP clients to a shared catalog. A prompt pipeline runs with private instructions on the service. A hybrid skill gives your agent a readable session guide and calls server tools whose implementation stays on SkillGild. Your agent still does the reasoning and local file work.

That distinction matters if a workflow needs a private validator or another server operation. You can use the capability without copying its implementation into your project. The run modes documentation explains exactly what is visible to the client.

Choose it for a supported workflow in the skills catalog. Check the listing's inputs, allowance and dependencies first. Setup currently requires the Go CLI, sign-in and an MCP connection. Automated creator payouts are on the roadmap; they aren't a reason to choose SkillGild today. Start with the Claude Code installation guide or Codex skills guide; if you don't write code, the no-code quickstart lets your assistant do the setup.

2. Skillry.dev: creative workflows with previews

Skillry.dev emphasizes design, video, images and presentations. Its listings make the intended output easy to inspect. Its installation guide documents downloading the complete skill folder, including supporting files. Its product introduction describes curation and examples.

Start here when a preview closely matches your creative brief and you want the downloadable package. Check the specific workflow's tools and providers; having the files doesn't remove those dependencies. Read SkillGild vs Skillry for the runtime tradeoff. Skillry.ai is a separate discovery site.

3. Agensi: downloadable instructions and creator sales

Agensi's about page describes reusable SKILL.md files that work independently of an Agensi runtime. Its MCP setup guide covers discovering, buying and installing skills through an assistant. Those are marketplace operations; don't confuse them with executing the skill's task remotely.

Agensi also publishes a creator offer with pricing and payout terms. Check those terms directly if selling files is your goal. Our Agensi comparison separates that offer from SkillGild's hosted execution model.

4. skills.sh: open skill discovery and installation

skills.sh provides a directory and installer for the open agent skills ecosystem. It's a useful starting point when you want to find a repository-based workflow and bring its files into the agent you already use.

Open the upstream repository before installing. Check its license, required tools and update history. A familiar publisher and a well-documented task can matter more than a high install count. The Claude Code install guide explains how local skill folders and hosted connections fit together.

5. SkillsMP: search across public skill repositories

SkillsMP aggregates skills from GitHub and provides discovery across categories. Use it when finding candidate sources is your main problem.

Evaluate the repository behind each result. An indexed entry doesn't establish that the workflow matches your project or will keep working. For installation and ownership decisions, read the best Claude Code skills roundup.

6. Skillzy: downloadable agent packs

Skillzy covers agent setups, skills and other workflow packs. Its delivery guide describes downloaded bundles containing files such as instructions, configuration and a README.

Check the exact pack contents against your existing setup. A package built around a particular integration can be useful for that job, but may need adaptation when your tools or data differ.

7. Skillery: a registry with a CLI workflow

Skillery's documentation covers login, installing skills and bundles, and choosing an agent platform. It's another option when a registry and install workflow are what you need.

Compare the specific skill and its dependencies. Registry installation and a hosted task runtime answer different questions.

Claude-focused skill directories

If you want to browse public Claude skills rather than run a hosted one, these directories are worth knowing. We have not audited their catalogs, and their listing counts, scores and rankings are their own claims, as of October 5, 2026.

skills.sh is the open skills directory covered above, with a command-line installer that works across coding agents.
ClaudeMarketplaces.com is a directory of Claude Code plugins, skills and MCP servers, ranked by installs, GitHub stars and usage.
SkillsClaude.org presents itself as a Claude skills marketplace for browsing and downloading official and community skills.
Cult of Claude indexes Claude skills and subagents from public GitHub, with each entry's source file, a quality score and a copy-and-paste install command.

Most directories like these list skills copied from public repositories, so you download and run the files yourself. A hosted skill works differently: the protected parts run on the service, as described in agent skills vs MCP servers. Check a directory entry's source and license before you install it, and see how to vet a third-party skill.

Other skill discovery and MCP platforms

AgentSkill.sh, LobeHub Skills and Skillry.ai are additional places to investigate. Their audiences and delivery methods differ, so they aren't interchangeable entries in a universal league table.

Anthropic's official marketplace includes enterprise products and procurement. Third-party sites using “Claude marketplace” in their domain aren't automatically Anthropic services. Smithery and Glama address MCP connections and hosting; include them when your problem is tool infrastructure.

How to choose an AI agent skill marketplace

Write down one task and the files you expect at the end. Then ask:

Does the listing show an output similar to mine?
Do I want to edit the instructions, or call a capability whose internals I don't need?
Which local libraries, providers and account permissions are required?
What happens if the service or upstream repository becomes unavailable?

Test the task before making the workflow a team dependency. Keep the client version and input with the output so you can repeat it after updates.

Frequently asked questions

Can I use these marketplaces with Codex and CLI coding agents?

Several support multiple clients, but installation paths and tools vary. Check the marketplace and the specific listing. Start with our Claude Code install guide to understand the two delivery routes.

Are paid agent skills automatically better than free skills?

No. Price doesn't establish fit or quality. Evaluate the instructions, required tools, example output and maintenance terms. A free local skill can be the right choice for project conventions; a hosted tool can be useful for a separate operation.

Is an MCP marketplace the same as a skills marketplace?

A skill teaches a method. MCP connects an agent to tools and data. A marketplace can use MCP to deliver discovery or execution, so inspect which operations it actually exposes. Read agent skills vs MCP servers for examples.

Originally published at skillgild.dev.

SkillGild vs Agensi: hosted capabilities or downloadable skills?

SkillGild — Tue, 06 Oct 2026 22:04:44 +0000

Choose SkillGild when a catalog workflow fits your task and you want to call its hosted capabilities from your existing agent. Choose Agensi when you want reusable skill files to install, or a marketplace that advertises a creator sales and payout offer. SkillGild vs Agensi is mainly a decision about delivery and execution.

SkillGild vs Agensi at a glance

Question	SkillGild	Agensi
What do you receive?	A wrapper and an authenticated runtime interface	Downloadable skill instructions
Where does the task run?	Prompt pipelines on the service; hybrid work split between your agent and server tools	The installed skill runs through your agent and its required tools
What does MCP do?	Discover skills, start sessions and call hosted tools	Documented discovery, purchase and installation operations
What can you inspect?	Wrapper, schemas and hybrid session guide; server implementation stays private	Delivered skill files; external service internals depend on the workflow
Creator commercial offer	Automated payouts remain planned	Published listing, pricing and payout terms
Dependency to consider	SkillGild access plus any local rendering tools	The skill's own libraries, tools and services

We publish SkillGild. This comparison favors its hosted capability use case while stating where Agensi is the stronger fit. It is based on documentation checked October 4, 2026 and SkillGild's implementation, not purchased-workflow benchmarks.

Downloaded instructions and hosted operations

Agensi describes its format as a reusable SKILL.md file with no Agensi task runtime. That is useful when you want a file-based workflow that your agent can load and you can keep using independently of marketplace access. A downloaded skill may still call outside services or require libraries; “downloadable” doesn't mean every task runs offline.

SkillGild has two run modes. Prompt pipelines keep their private prompt on the service. Hybrid skills return an agent-readable guide, then expose server tools for operations that stay hosted. The wrapper isn't a download of those server implementations. Your agent can still create and render local files.

If your requirement is “I must inspect and change every part of the workflow,” a protected server operation won't satisfy it. If your requirement is “I need this operation through an authenticated interface,” keeping its implementation hosted can be useful.

MCP discovery doesn't establish hosted execution

Agensi's MCP guide documents an assistant connecting to the marketplace to find, buy and install skills. That's convenient distribution. It doesn't, by itself, mean the downloaded skill's task is computed by Agensi.

SkillGild's agent sessions expose a different operation: an entitled agent receives a session and can call its listed server tools. Compare the actual operations rather than choosing based on the presence of an MCP badge. Our skills vs MCP guide explains why both layers can appear in the same workflow.

A plotting task makes the tradeoff concrete

Suppose you have a CSV and need a figure for a paper. With a downloaded plotting skill, your agent follows its installed instructions and uses the tools that package requires. With SkillGild's Academic Plotting hybrid skill, your agent follows the session guide, creates plotting code locally and calls the hosted palette validator.

Neither delivery method proves that your scientific conclusion is correct. You still check the data, uncertainty, axes and export size. See our research plots walkthrough for an explicit input and review checklist, and inspect the Academic Plotting listing before connecting.

Creator sales: check what is live

Agensi advertises creator-set pricing, one-time sales and subscriptions, with a 70% creator share and Stripe or USDC payout routes. Those are its stated terms; this review hasn't verified a completed payout. Consult the current offer before publishing.

SkillGild reviews creator applications and published versions (see how to build and publish a skill), but automated pricing and payouts remain on its roadmap. Creator-uploaded executable server tools also aren't a self-service feature today. We don't recommend SkillGild on the premise that it already provides that commercial infrastructure.

For a creator, the useful question is what you intend to distribute. A file can contain your instructions and bundled scripts. A hosted implementation gives the caller an interface and results instead. Access control can reduce direct distribution of source, but doesn't guarantee that no one can imitate behavior or infer information from outputs.

Review, cost and access

Agensi publishes its security review process. SkillGild gates publication through review. Those statements don't establish a comparative security win, and we haven't conducted a security assessment of either platform.

Read each listing's access terms and required providers. SkillGild's free allowance and paid entitlement are separate from your agent's model costs. A purchased skill may also need a model subscription or paid API. We haven't measured cost per completed task across the two services.

Which should you use?

Start with SkillGild for a supported hosted capability, and follow the Claude Code or Codex installation guide. Start with Agensi for downloadable instructions or its stated creator sales offer. If price and catalog size decide it for you, compare SkillGild vs Skillry. You can keep local project conventions alongside hosted tools.

For more options, use our agent skill marketplace shortlist. Compare one task and its dependencies before adding a second marketplace account.

Originally published at skillgild.dev.

SkillGild vs Skillry: pricing, delivery and which to choose

SkillGild — Tue, 06 Oct 2026 22:04:36 +0000

Short answer: SkillGild costs less ($6.99 a month or $49 a year, against Skillry's $9.99 and $79) and its free skills each come with 25 runs a month. Its skills run hosted tools, such as validators, that stay on SkillGild's servers. Skillry.dev has a much larger creative catalog, hands you the complete skill folder to keep, and sells a one-time lifetime plan. Pick SkillGild for price and hosted tools; pick Skillry for catalog size and owning the files.

We publish SkillGild, so read this as a comparison from one side. Every Skillry fact below comes from its public pages, checked on 4 October 2026 and linked where it is used. We don't claim a measured winner on output quality or speed.

SkillGild vs Skillry at a glance

	SkillGild	Skillry.dev
Monthly price	$6.99	$9.99
Yearly price	$49 ($4.08 a month)	$79 ($6.58 a month)
Other plans	$18.99 every 3 months	$169 one-time lifetime
Free tier	Free skills with 25 runs a month each, no card	Free skills marked on the catalog; sign-in required
Catalog	A growing catalog of hosted skills	About 410 skill listings
What you install	A small wrapper; tools run hosted	The complete skill folder
Private part	Server tool code and prompt pipelines	None stated; you receive the files
Install	Build the Go CLI, sign in, register MCP	Install prompt, CLI (Node.js 22+) or ZIP
Agents with guides	Claude Code, Codex, Cursor, Gemini CLI	Claude Code, Codex, Cursor and more
Refunds	Double charges, failed activation, billing errors	"Payments are non-refundable"
Affiliate program	25% of the first 10 payments, then 10% for as long as they pay	40% for the first 12 months

Skillry's prices come from its pricing page, its catalog count from its public sitemap, and its install steps from its installation guide. SkillGild's prices are the US dollar list prices on our pricing page, outside India.

Pricing: SkillGild costs less on every recurring plan

SkillGild's monthly plan is $3 cheaper than Skillry's, 30% less. On yearly billing the gap is $30 a year, 38% less: $49 against $79. Over two years, the difference adds up.

Two years of Pro	SkillGild	Skillry
Monthly plan × 24	$167.76	$239.76
Yearly plan × 2	$98	$158
Lifetime, paid once	No lifetime plan	$169

Skillry's $169 lifetime plan is the one place it can cost less over time: it breaks even with SkillGild's yearly plan after about three and a half years. Skillry calls it a founding price that rises as its library grows.

Two more cost differences matter before you pay anything:

Free use. Most SkillGild skills are free, each with 25 runs a month, and no card is needed. Skillry also lists free skills, and asks you to sign in before installing them.
Refunds. SkillGild's refund policy refunds double charges, payments whose Pro access didn't activate, and charges made in error. Skillry's pricing page states that payments are non-refundable.

Price per month isn't the whole value. Skillry's subscription covers every Premium skill in a much larger catalog. SkillGild's Pro plan covers its Pro skills, each with a monthly session allowance, and its catalog is still growing. Compare what you'd actually use, not only the headline price. Model subscriptions, external APIs and local renderers can add costs on either service.

How each one delivers a skill

This is the real design difference, and it decides more than the price does.

Skillry delivers files. Its installation guide describes three routes: paste an install prompt into your agent, use the Skillry CLI (macOS or Windows, Node.js 22 or later), or download a ZIP and copy the folder in. You end up with the full skill folder, scripts and references included, in the place your agent reads skills from.

SkillGild delivers a connection. The CLI installs a small wrapper that tells your agent what the skill does and how to call it, then signs you in. When your agent uses the skill, it calls hosted tools over MCP. A hybrid session hands the agent a guide it can read, while tool code, such as a contrast validator or a render check, runs on SkillGild. A prompt pipeline runs its private prompt on the service. The run modes document both.

What that means in practice:

With Skillry you own a copy. You can read, edit and keep every file, and nothing depends on Skillry once it's installed, apart from any services the skill itself calls.
With SkillGild the hosted part stays current and private. Tools improve without a reinstall, and a creator's server code isn't handed out. In exchange, the skill depends on the service and your monthly allowance.

Neither model is better for every task. If you want to adapt a skill's files, Skillry's model fits. If the valuable part is a server-side check or pipeline, SkillGild's does.

Catalog: size against hosted tools

Skillry is the bigger catalog by far. Its sitemap lists about 410 skill pages, weighted toward creative work: web pages, images, presentations and video, each with output previews. Its marketplace describes skills as curated and reviewed in-house.

SkillGild's catalog is newer and growing, with hosted skills across design, video, research plotting and development. Its free skills carry an open license (MIT or Apache 2.0), shown on each skill's page:

Taste Skill for frontend design briefs
Brag, HyperFrames and Lyric Music Video for video
Academic Plotting, which checks chart colors against contrast targets with a hosted validator
Logo Design and LiveCanvas

If you need a specific creative style today, Skillry is more likely to have it. If one of SkillGild's skills covers your task, its hosted tools are the reason to choose it. The plotting guide shows a recorded production run with the validator's actual results.

Setup

Skillry is quicker to start: paste an install prompt, run its CLI, or copy a folder.

SkillGild currently asks for more: build the Go CLI from source, sign in through your browser, then register the MCP server with your agent. Prebuilt installers are planned. The Claude Code setup guide walks through it, and the install guide covers Codex, Cursor and Gemini CLI.

Affiliate programs compared

Both services pay affiliates a recurring commission, but on very different terms. Skillry's terms come from its affiliate page; SkillGild's from its affiliate program page.

	SkillGild	Skillry.dev
Commission	25% of the first 10 payments, then 10%	40% of payments
How long it lasts	For as long as the customer pays	12 months from the first purchase; "not a lifetime commission"
Joining	Automatic: every account is an affiliate account	Separate sign-up and enrollment on a PromoteKit portal
Tracking	Your link holds your code in the visitor's browser until sign-up, with no expiry; people can also enter your code by hand	PromoteKit link tracking; blocked cookies can affect attribution
Dashboard	On the affiliate page, in your SkillGild account	PromoteKit dashboard
Payouts	Requested from your account once your balance reaches $20; paid by PayPal, bank transfer or UPI after a 30-day refund hold	Handled manually; contact Skillry for arrangements
What your audience pays	$6.99 a month or $49 a year	$9.99 a month or $79 a year

Per customer, Skillry pays more for the first few years: 40% of a higher price adds up quickly, then stops after 12 months. SkillGild's commission is smaller per payment but never stops, so it suits audiences who stay. It also needs no separate portal, and because someone you refer can type your code in by hand, a blocked cookie or a different device doesn't lose you the referral. A lower price can also be an easier recommendation to make.

SkillGild credits commission automatically when a referred member's Pro payment is verified, holds it for 30 days in case of a refund, and pays it out on request from the affiliate page.

Which should you choose?

Choose SkillGild if price matters, you want free monthly runs before paying, or your task benefits from hosted validators and pipelines whose code stays private. It's also the one with refunds when billing goes wrong.

Choose Skillry.dev if you want the widest creative catalog, need to own and edit the skill files, or prefer one lifetime payment.

Either way, start with one small task, check the files and dependencies it produces, then decide. If you're still comparing options, read our AI agent skill marketplace comparison or SkillGild vs Agensi.

How we compared

We read each service's public pricing, installation, catalog and affiliate pages on 4 October 2026, counted Skillry's skill pages from its public sitemap, and took SkillGild's details from its live pricing and catalog. Skillry.ai is a separate company; this article covers Skillry.dev only. Prices and terms change, so check both pricing pages before you buy.

Originally published at skillgild.dev.

Claude skills: what they are and how to use them

SkillGild — Tue, 06 Oct 2026 22:04:27 +0000

Claude skills are folders of instructions, scripts and resources that Claude loads when a task matches, so it can repeat a workflow the same way each time. They give Claude a method for a task: how to review a design, prepare a document, plan a feature or make a research figure. Start by choosing your Claude environment, then choose a skill for the job you actually need to complete.

What are Claude skills?

A skill normally has a SKILL.md file with a name, a description and instructions. It can also contain scripts, references and assets. The description helps the agent decide when to load the workflow. Skills extend how an agent works; installing one does not change its underlying model. See Anthropic's explanation of skills.

SkillGild is an independent marketplace for hosted agent skills. Its current setup supports Claude Code through a local CLI and MCP connection. Browse the skills catalog for current access, allowances and installation instructions.

Claude.ai skills and Claude Code skills

The setup depends on where you use Claude. A Claude.ai upload guide and a terminal installation guide describe different workflows.

Environment	Where to start	What SkillGild supports here
Claude.ai	Manage enabled skills in Customize → Skills	This guide explains the native feature; the SkillGild installation below targets Claude Code
Claude Code on your machine	Put a skill folder in the project's or your user's skills directory	Install a public wrapper and connect the SkillGild MCP server
Other coding agents	Use that client's supported skill folder and MCP setup	Codex, Cursor and other MCP clients

For Claude.ai, enable code execution and file creation in Settings → Capabilities, then manage skills in Customize → Skills. Organization policies can affect availability. Follow the official Claude.ai setup guide for current upload and account requirements.

For local Claude Code, follow how to install Claude Code skills. A personal skill folder on your laptop and a hosted execution connection have different requirements; check the guide for the environment you are using.

Claude skill examples by job

Choose a workflow by its inputs and deliverables. These examples link to real SkillGild listings; the free Claude Code skills selection guide explains the catalog in more detail, and Claude Code skills for developers suggests which to add first if you write code.

Job	Skill	What to prepare
Improve a landing page or frontend	Taste Skill	The existing app, its audience and a concrete design brief (frontend design guide)
Design a logo	Logo Design	Brand name, positioning, constraints and required formats
Make a product launch video	Brag	The project you built and the story you want to show (video skills guide)
Create an HTML-based video	HyperFrames	A scene plan, assets and timing
Prepare figures for a paper	Academic Plotting	Your actual results, axis labels and publication requirements
Plan a feature before editing code	OpenSpec Propose	A feature request and the project's existing specifications

These workflows still need task-specific inputs and review. A plotting skill cannot infer missing measurements, and a design skill needs enough context to make appropriate choices.

How to choose a Claude skills marketplace

Check what the marketplace delivers. A local skill directory may distribute the full instructions and scripts. SkillGild installs an invocation wrapper and provides access to hosted capabilities. Its hybrid skills give your agent session instructions while private server tools run on SkillGild; prompt skills return a hosted model result.

Before installing, check the listing's purpose, client support, public input schema, local dependencies and access allowance. For video work, also check the renderer and assets required. A download count or a large directory does not tell you whether a skill fits your project.

If you want free skills, check each listing's monthly run allowance. Free SkillGild access and your coding agent's model costs are separate. See pricing for current plan terms.

Skills, MCP and project instructions

Skills provide task-specific procedures. MCP connects an agent to server capabilities. A project instruction file gives the agent ongoing context and conventions for that repository. These can work together: project instructions describe your codebase, a skill supplies a workflow, and an MCP tool performs a particular operation.

In SkillGild, the wrapper tells the agent how to start a hosted workflow. Copying that wrapper alone does not provide the private tools or their implementation. Read agent skills vs MCP servers for the execution details.

If you are deciding between a free repository and a hosted listing, read the best Claude Code skills roundup. For a worked task, see the research plots walkthrough.

Start with one workflow

Pick a task you expect to repeat, such as reviewing a frontend or creating a research figure.
Open the relevant skill listing and read its requirements.
Follow the Claude Code installation guide.
Give Claude a complete brief, invoke the installed skill and review the result against your requirements.

If you use several coding agents, the Claude Code install guide shows which setup belongs to each client. To run Claude skills from your own code instead of a chat, see the agent skills SDK guide.

Originally published at skillgild.dev.

How to install Claude Code skills (and skills for Codex, Cursor and Gemini CLI)

SkillGild — Tue, 06 Oct 2026 22:04:18 +0000

A Claude Code skill is a folder with a SKILL.md file. Installing one means putting that folder where Claude Code looks and starting a new session. This guide covers the three places skills live, the three ways to install one (copy a folder, install a plugin, or use the SkillGild CLI), how to confirm it loaded, what to do when it does not, and the same steps for Codex, Cursor and Gemini CLI.

Where Claude Code looks for skills

Scope	Path	Applies to
Personal	`~/.claude/skills/<name>/SKILL.md`	Every project on your machine
Project	`.claude/skills/<name>/SKILL.md`	This repository, for everyone who clones it
Plugin	Inside an installed plugin's `skills/`	Every project, managed by `/plugin`

Claude reads each skill's name and description when a session starts and loads the full instructions when a request matches. A skill added mid-session is picked up by the next session.

Option 1: copy a folder from GitHub

Most community skills are a folder in a public repository. Clone the repository and copy the folder:

git clone --depth 1 https://github.com/obra/superpowers /tmp/superpowers
cp -r /tmp/superpowers ~/.claude/skills/superpowers

For a repository that holds several skills under skills/, copy the one you want:

git clone --depth 1 https://github.com/mattpocock/skills /tmp/mattpocock-skills
cp -r /tmp/mattpocock-skills/skills/grill-me ~/.claude/skills/grill-me

Read SKILL.md and any scripts before you install. A skill can run code on your machine; prefer skills with a named maintainer and a license file.

Option 2: install with the SkillGild CLI

The SkillGild CLI does the clone-and-copy for any listed community skill and knows which folder each one lives in:

curl -fsSL https://raw.githubusercontent.com/SkillGild/skillgild/main/scripts/install-cli.sh | sh
skillgild install grill-me --agent claude-code

It clones the repository, copies the skill folder into ~/.claude/skills/grill-me/, and prints the license and author. Add --target .claude/skills to install into the current project instead, or --force to replace an existing copy. Every skill page on SkillGild shows this command with the right slug, next to the project's own plugin or npx commands when it publishes them.

Option 3: install a plugin

Projects that publish a Claude Code plugin can be installed from inside Claude Code:

/plugin marketplace add anthropics/claude-plugins-official
/plugin install frontend-design@claude-plugins-official

A plugin can carry several skills plus commands, agents and MCP servers; see Claude Code plugins for how they work and when a plain folder is simpler.

Installing a hosted SkillGild skill

Hosted skills run through SkillGild rather than from a folder, so they need the CLI signed in and the MCP server registered once:

skillgild login
claude mcp add --scope user skillgild -- $(command -v skillgild) mcp
skillgild install academic-plotting --agent claude-code

The install writes a small wrapper into ~/.claude/skills/academic-plotting/ that tells Claude how to start a session; the skill's guide and server tools arrive from SkillGild when it runs, after your access is checked. Free hosted skills include monthly runs; see each listing for its terms.

Check that it loaded

Start a new session and ask for the job in natural language without naming the skill:

Grill me on this plan before I start: migrate the auth service to the new token format.

Claude says when it uses a skill, or you will see its steps in the behaviour. In recent versions you can also type /grill-me to invoke a skill directly, and the slash menu lists what is installed.

Troubleshooting

Nothing happens. Check the path: ~/.claude/skills/<name>/SKILL.md, with the file at the top level of the folder, not nested in a second folder from the clone.
The skill exists but never triggers. Its description does not match how you ask. Open SKILL.md, read the description, and use its words, or invoke it by name.
Frontmatter error. The --- block must be the first thing in the file with name: and description: inside it, and name must match the folder name.
It worked yesterday. Sessions load skills at start; restart the session after any change.
The CLI says the folder has no SKILL.md. The listing's folder path is wrong or the project moved it. Use the manual commands on the skill page and tell us through the report link on that page.
A hosted skill says sign in. Run skillgild login and confirm the MCP server is listed by claude mcp list.

Other agents

The folder format is the open Agent Skills standard, so the same skill works elsewhere. Only the location changes:

Client	Personal folder	Project folder	After installing
Codex	`~/.agents/skills/`	`.agents/skills/`	Start a new session
Cursor	`~/.cursor/skills/`	`.cursor/skills/`	Start a new session
Gemini CLI	`~/.gemini/skills/`	`.gemini/skills/`	Run `/skills reload`

The SkillGild CLI writes to each with --agent codex, --agent cursor or --agent gemini-cli, and hosted skills reach every MCP client through the same skillgild mcp server. The dedicated guides cover each client's connection settings: Codex, Cursor and Gemini CLI.

What to install first

If you have nothing installed yet: one planning skill (grill-me or Superpowers), one writing skill (Humanizer), and one for your main job from the best Claude Code skills. Then write your own for the thing you do every week, following how to create a Claude skill.

Originally published at skillgild.dev.

How to install skills in Codex CLI

SkillGild — Tue, 06 Oct 2026 22:04:08 +0000

Codex skills are folders with a SKILL.md file that teach Codex how to do one kind of task, such as reviewing a change, planning a feature or making a figure. Codex CLI loads local skills from .agents/skills/ in a repository and ~/.agents/skills/ for your user. Each skill has its own folder containing SKILL.md. Hosted SkillGild skills use the same local discovery pattern, with a wrapper that calls the SkillGild MCP connection for protected capabilities.

For a real example of a tool that installs its workflow as Codex skills, see the OpenSpec guide: openspec init writes six skills into .agents/skills/.

Add a local skill to Codex

Choose a project folder for a team workflow or a user folder for your personal setup. Preserve any scripts, references and assets distributed with the skill. For example:

your-project/
  .agents/
    skills/
      review-brief/
        SKILL.md

The file needs a name, description and actionable instructions:

---
name: review-brief
description: "Check a product brief for missing requirements before coding."
---

Read the brief. List missing inputs and conflicting requirements.
Propose testable acceptance criteria. Resolve open questions before editing files.

In Codex CLI, use /skills or type $ to select the skill. Codex can also choose it from its description. Check the official skills documentation for current folder discovery and supported interfaces. The example above uses the local skill system; it does not need SkillGild.

Connect Codex to hosted skills

1. Install and sign in to the SkillGild CLI

Follow Install the CLI, which currently uses Go 1.26 or later and the SkillGild source checkout. Then run:

skillgild login
skillgild status

Approve the device code in your browser. SkillGild keeps the credential in your operating system's credential store.

2. Register the local MCP server

Find the absolute executable path with command -v skillgild on macOS/Linux or where.exe skillgild on Windows. Substitute that path:

codex mcp add skillgild -- /absolute/path/to/skillgild mcp
codex mcp list

In a Codex CLI session, /mcp shows active servers. The command starts a local stdio bridge; you do not need to paste a SkillGild API key into Codex's MCP configuration. See the official Codex MCP guide for server management.

3. Install a wrapper for a real catalog skill

For a frontend workflow:

skillgild install design-taste-frontend --agent codex

The CLI writes ~/.agents/skills/design-taste-frontend/SKILL.md. Its codex preset chooses that user directory.

The Taste Skill listing describes the workflow and current access requirements.

4. Invoke the workflow in your project

Use $design-taste-frontend to review this landing page. The audience is
independent consultants. Keep the existing routes and branding, explain
the proposed design direction, then implement and check the mobile layout.

For hybrid SkillGild skills, Codex follows the session guide with its own model and calls SkillGild's server tools where required. A prompt skill returns a hosted response through skillgild_run_skill. Installing a wrapper does not copy either skill's private implementation to your machine.

Recommended Codex skills

These are the hosted skills on SkillGild that suit a Codex workflow, grouped by the work you need.

Task	Listing to inspect
Frontend design or a landing-page redesign (design skills guide)	Taste Skill
Feature planning from existing specifications	OpenSpec Propose
Research plots and paper figures	Academic Plotting
A launch video for a project	Brag

Read each listing's requirements and public schema before starting. Video and plotting workflows may require local renderers or libraries. The catalog selection guide covers these hosted workflows; despite its Claude Code title, the listed skills also support connected Codex agents.

Troubleshoot Codex skill setup

If the skill is missing, check its SKILL.md file and installation scope. If a change does not appear, restart Codex. If the wrapper is visible but a hosted call fails, check codex mcp list and skillgild status separately: skill discovery and server connectivity are two different checks.

Use the server's returned access, quota or input error to choose the next step. Reinstalling the wrapper will not reset a monthly allowance. SkillGild's agent quickstart documents error handling.

This guide is grounded in the current official documentation and SkillGild CLI source. The account approval and authenticated runtime steps require your own connection.

Other CLI and coding agents

Use Claude Code installation for .claude/skills/, Cursor setup for its MCP configuration, or the Claude Code install guide to compare clients.

Originally published at skillgild.dev.

Cursor MCP setup for agent skills

SkillGild — Tue, 06 Oct 2026 22:03:53 +0000

To connect SkillGild to Cursor, install and sign in to the SkillGild CLI, then register its absolute executable path in Cursor's mcp.json as a local stdio server. An optional skill wrapper in ~/.cursor/skills/ helps the agent recognize when to use a hosted workflow.

Choose a project or personal connection

Cursor supports .cursor/mcp.json inside a project and ~/.cursor/mcp.json for your personal setup. Project configuration takes precedence when the same server name appears in both. The official Cursor MCP guide explains configuration, tool approvals and logs.

Use personal configuration if you want the connection available across projects. Use project configuration when the team needs the same server definition. Each teammate still signs in on their own machine; the configuration below contains no account credential.

Connect SkillGild to Cursor

1. Install the CLI and approve your device

Follow Install the CLI. The current method uses Go 1.26 or later and the SkillGild source checkout. Then run:

skillgild login
skillgild status

Confirm the browser's device code. The CLI stores its credential in the operating system's credential store, which the MCP process uses.

2. Find the executable path

On macOS or Linux:

command -v skillgild

On Windows, use where.exe skillgild. Use the resulting absolute path because an application launched outside the terminal may have a different PATH.

3. Add the MCP configuration

Open your chosen mcp.json. Merge the skillgild entry into its existing mcpServers object so other connections stay intact. Replace the placeholder command with your executable's absolute path:

{
  "mcpServers": {
    "skillgild": {
      "type": "stdio",
      "command": "/absolute/path/to/skillgild",
      "args": ["mcp"]
    }
  }
}

On Windows, use forward slashes or escaped backslashes in JSON paths. Save the file and restart Cursor. Inspect the connection in its MCP controls; the current interface exposes MCPs through Customize. Follow your configured tool approval policy when starting a workflow.

4. Install an optional Cursor skill wrapper

skillgild install logo-design --agent cursor

The CLI writes ~/.cursor/skills/logo-design/SKILL.md. Cursor's skills documentation explains local skill discovery. The wrapper identifies the workflow and how to call it; it requires the MCP connection for hosted tools.

5. Ask Agent to use a skill

Use the SkillGild Logo Design skill for a fictional cycling club called
North Loop. Start with three geometric concepts. Check one-color use
and small sizes, and show the proposed files before finalizing them.

For a hybrid skill, the agent starts a session, receives its instructions, calls the declared hosted tools where needed and closes the session. For a prompt skill, it calls skillgild_run_skill. Inspect the Logo Design listing for current inputs and access.

If Cursor cannot connect to the MCP server

Symptom	Check
Server executable cannot be found	Use the actual absolute path; test `skillgild status` in a terminal
Configuration is not recognized	Validate the JSON, its `mcpServers` object and the correct project/user file
The wrong server definition is used	Look for the same name in project and user configuration
Server appears but hosted calls fail	Check the CLI's account connection, then inspect the returned error
No tool is called for your task	Ask explicitly for the installed skill and review the available/enabled tools

For server logs, open Cursor's Output panel and select MCP Logs. A local wrapper appearing in the skill list does not confirm that the server is connected. See SkillGild's agent error handling for access and quota failures.

These configuration details were checked against Cursor documentation and the SkillGild CLI. An authenticated task still depends on your account approval and local environment.

Choose a workflow or another client

Browse hosted agent skills, compare skills and MCP, or follow the Claude Code and Codex CLI guides. The Claude Code install guide connects these setup routes.

Originally published at skillgild.dev.

Agent skills vs MCP servers

SkillGild — Tue, 06 Oct 2026 22:03:42 +0000

Agent skills and MCP servers solve different problems, and they work together. A skill teaches an AI agent how to do a job well. An MCP server gives an AI agent a way to reach a tool or a system. This page explains the difference, when you need each, and how SkillGild uses both.

The short answer

	Agent skill	MCP server
What it is	Instructions and supporting resources for a specific task, commonly packaged in a SKILL.md folder	A protocol endpoint that exposes tools, resources or prompts to an AI client
What it answers	"How should this task be done?"	"How does the agent reach this tool or data?"
Typical example	Review a pull request against a checklist, plan a logo, write a project proposal	Query a database, read a calendar, call an API
Where the know-how lives	In the skill	In your code behind the server
Who maintains it	The skill's creator	Whoever runs the server

A rule of thumb: if you are describing a method, it is a skill. If you are describing a connection, it is an MCP server.

What is an agent skill?

An agent skill packages instructions and supporting resources for a specific task. The Agent Skills standard defines a folder containing a SKILL.md file, with optional scripts, references and assets. A skill gives an agent a documented method it can reuse; it does not guarantee the output will always be correct.

Skills are useful when the same kind of job comes up again and again and you want it done the same good way each time.

What is an MCP server?

The Model Context Protocol (MCP) is an open standard for connecting AI clients to external capabilities. Servers can expose tools, resources and prompts. Tools let an agent query a service or perform an action, while resources supply context and prompts supply reusable interaction templates.

MCP standardizes how a client discovers and accesses those capabilities. A skill can supply the workflow that uses them. Tool descriptions and server prompts can also guide the agent, so the two are complementary rather than a strict split between instructions and actions.

How they work together on SkillGild

SkillGild is a marketplace of skills and a hosted runtime that runs them. MCP is how your agent reaches that runtime.

You sign in once with the skillgild CLI, which stores a revocable credential in your operating system's credential store.
The CLI runs as a local MCP server and registers with Claude Code, Codex, Cursor, Gemini CLI or any other MCP client.
Your agent discovers a skill and reads its public schema. Installing it adds a small SKILL.md wrapper, rather than the protected implementation.
For a prompt-based skill, your agent calls skillgild_run_skill; SkillGild checks access and allowance, runs the prompt remotely and returns a result.
For a hybrid skill, your agent starts a session, receives a guide and calls hosted server tools. Your agent does the reasoning and local file work; the server tool code runs on SkillGild.

The same task shows where each part happens. In a figure task, your agent reads your data, writes and runs the plotting code and inspects the result, while the hosted side checks access, starts the session and answers server-tool calls.

So MCP is the transport, and the skill is the capability. You do not choose between them: one MCP connection gives your agent access to every skill you are entitled to run.

For the exact commands for each agent, see Quickstart for AI agents, and for the run flow in detail, see the documentation overview.

Hosted skills vs files you maintain yourself

Many skills are plain instruction files that live in a project or a home directory. Those are fine for a single team. A hosted skill changes three things:

Implementation stays hosted. Prompt-based skills keep their protected prompt encrypted at rest and load it only for an authorized run. Hybrid skills keep server tool code on SkillGild, while sending the guide to your entitled agent. The configured model still receives prompt instructions, so hosting reduces direct copying but cannot stop someone approximating behaviour from outputs.
One account governs access. Sign-in, allowances and revocation are the same across every agent and client.
Failed prompt runs release the reservation. Provider and platform failures do not consume the reserved free-run allowance. A hybrid session counts as a run when it starts; it then permits a limited number of server tool calls until expiry.

When to use which

Use a skill when you want a repeatable, high-quality way of doing a task, such as a design review, a research brief or a video storyboard.

Use an MCP server when your agent needs access to something it cannot reach on its own, such as your database, an internal API or a SaaS product.

Use both when a skill's method needs live data. The skill defines the approach; your MCP tools supply the facts.

Frequently asked questions

Are agent skills the same as MCP tools?

No. An MCP tool is a callable action exposed by a server. A skill is a packaged method for doing a type of job. A skill can be delivered through MCP, which is how SkillGild serves them to your agent.

Do I need MCP to use SkillGild skills?

For coding agents, yes: the local CLI registers as an MCP server. You can also call skills directly through the REST API or the TypeScript, Python and Go agent skills SDKs from your own application.

Which agents support SkillGild?

Claude Code, Codex, Cursor and Gemini CLI have documented setup steps. Any other MCP client can connect to the same local server.

Next steps

To see both in a coding workflow, read Claude Code skills for developers. Comparing providers? See SkillGild vs Agensi and the best Claude Code skills roundup.

Browse the catalog to find a skill for your agent.
Follow the Quickstart for AI agents to connect it.
Read Core concepts for versions, allowances and access.

Originally published at skillgild.dev.

Best Claude Code skills in 2026: 27 picks by job

SkillGild — Tue, 06 Oct 2026 22:03:23 +0000

A skill gives Claude Code a method: how to review a plan, how to lay out a page, how to write a figure that survives print. This list groups the skills worth installing by the job you want done. It mixes two kinds: community skills, open-source folders maintained on GitHub that SkillGild lists and credits, and hosted skills, which run through SkillGild with free monthly runs. Each entry links to its SkillGild page, where the install command, license and author are shown.

Every skill here installs with one command once the SkillGild CLI is set up:

skillgild install <slug> --agent claude-code

Use --agent codex, cursor or gemini-cli for other clients; the folder format is the same.

Writing

Humanizer by blader. Rewrites AI-sounding text so it reads like a person wrote it, using the patterns catalogued in Wikipedia's guide to AI writing, then audits its own output. The most-searched community skill of the year.

Stop Slop by Hardik Pandya. Seven rules that strip the tells (not-X-but-Y contrasts, staged openers, forced triads, filler closers) from any draft. Many people run it as the final pass after Humanizer.

Writing Guidelines by Vercel. Reviews documentation and product prose against 80-plus rules from Vercel's style guide. Best for docs and UI copy rather than essays.

Planning and workflow

Superpowers by Jesse Vincent. A complete development methodology as composable skills: brainstorm, plan, work test-first, review, hand off. Install it when you want Claude Code to behave like a disciplined engineer rather than a fast typist.

grill-me by Matt Pocock. Interviews you about a plan, one question at a time, until the holes are gone. Run it before any non-trivial change. From the same author: Handoff compacts a long conversation into a document another agent can continue from, and TDD enforces a red-green-refactor loop.

GSD. A context-engineering framework that runs Claude Code through phases with planning, verification and fresh context per phase. Heavier than Superpowers; suits long builds.

Karpathy Guidelines. Four rules drawn from Andrej Karpathy's observations on how LLMs fail at code: think before coding, simplicity first, surgical changes, verify. Small, and worth installing everywhere.

Ponytail by Dietrich Gebert. The lazy senior developer ruleset: climb the dependency tree before writing anything, reuse what exists, write less code.

OpenSpec Propose (hosted). Spec-first proposals that turn an idea into a change proposal with requirements and tasks before any code, following the OpenSpec workflow.

Frontend and design

Impeccable by Paul Bakaus. A design language for AI harnesses with 24 commands to craft, audit, polish and harden interfaces. The most complete design skill available.

Taste Skill (hosted; from Leonxlnx's taste-skill). Anti-slop defaults for landing pages and product UI: layout, type, colour and spacing rules that keep generated pages from looking generic. Read frontend design skills for briefs that work.

Frontend Design by Anthropic. Anthropic's own baseline for distinctive interface code, shipped in the official plugin marketplace.

UI UX Pro Max. A searchable database of styles, palettes and font pairings that the agent reasons over before it codes. Good when you need options rather than one opinion.

Emil Kowalski's skills: Animate, Apple Design and design engineering. Motion and polish from a design engineer's point of view: easing, springs, when not to animate.

Logo Design (hosted). SVG logo marks from a brief, with variants and a review checklist.

Testing and review

Playwright Skill by lackeyjb. General-purpose browser automation: the agent writes and runs Playwright scripts to click through a flow, screenshot every route and capture console errors. Pair it with the Playwright MCP server from the best MCP servers for Claude Code.

Webapp Testing by Anthropic. A verification method for local web apps in a real browser.

Code Review and Security Guidance by Anthropic. Official plugins: a structured review of a diff or pull request, and pattern warnings on risky code as it is written.

Research and data

Deep Research by 199 Biotechnologies. An eight-phase pipeline (scope, plan, retrieve, triangulate, synthesise, critique) that returns cited reports with source-credibility scores.

Scientific Agent Skills by K-Dense. 177 validated skills for science: single-cell RNA-seq, structure prediction, statistics, figure generation.

Academic Plotting (hosted). Publication-quality matplotlib figures with a hosted palette validator. See the research plots walkthrough for a recorded run.

last30days. Researches any topic across Reddit, X, YouTube, Hacker News and GitHub for the last thirty days, which is what you want for "what are people saying about" questions.

Documents and productivity

Anthropic's document skills: pptx, docx, xlsx and pdf. Create and edit PowerPoint decks, Word documents, Excel workbooks with live formulas, and read, merge, split and fill PDFs. They are source-available rather than open source: install and use them, but do not redistribute them.

Obsidian Skills by Steph Ango. Official skills from Obsidian's CEO that teach an agent Obsidian-flavoured Markdown, canvases and properties so it edits a vault correctly.

I Have ADHD. Stops the agent burying the answer: short, action-first, numbered. Useful far beyond its name.

Marketing and SEO

Marketing Skills by Corey Haines. Sixty-plus skills for CRO, copywriting, SEO, paid ads, email, pricing and analytics. The largest marketing set and the one to install first.

Claude SEO by Agrici Daniel. 26 sub-skills and 19 specialist agents for full SEO audits: technical, content, schema, local, e-commerce, backlinks, sitemaps and generative-engine readiness.

Video

Brag (hosted). Turns a repository into a launch video. Remotion Skills by Remotion are the official skills for video in React. HyperFrames renders HTML compositions to video, and Lyric Music Video times animated lyrics to the syllable. Compare them in Claude Code video skills.

Images

Nano Banana by Keanan Koppenhaver. Generate and edit images from Claude Code with Google's Gemini image models; bring a Gemini API key. Excalidraw Diagram draws diagrams as editable Excalidraw files and renders them to check the layout.

Making your own

Skill Creator by Anthropic scaffolds a correct SKILL.md and runs an evaluation loop over your examples. The step-by-step version is in how to create a Claude skill.

How we chose

Each pick does one job well, is maintained by a named person or organisation, and is used widely enough that people search for it by name (see the state of Claude skills for the search data). We read every README and verified the repository, author and license before listing it on SkillGild; licenses marked "not stated" on a listing mean the repository had no license file at the time of review, so treat the code as all rights reserved until one is added.

Community skills run locally in your agent with your own model; SkillGild lists and credits them and installs them from source. Hosted skills run through the SkillGild MCP server, which keeps private prompts and server tools off your machine and counts runs against a monthly allowance. Both appear in the same catalog, and the Claude Code skills page lists everything that works in Claude Code.

Originally published at skillgild.dev.

Create research plots with Claude Code and Academic Plotting

SkillGild — Tue, 06 Oct 2026 22:03:15 +0000

This walkthrough shows how to turn a table of results into a clean, checked figure with a coding agent. It uses a small synthetic dataset made up for this page, a short matplotlib script and an explicit list of checks. None of the numbers are real research results, and a plotting skill does not run or write up a research project for you. It makes figures from the results you give it.

What this example covers

Academic Plotting is a hosted SkillGild skill that picks a chart type for results and writes matplotlib or seaborn code, or plans an architecture diagram from a method description. The script and output below were produced by running the plotting code locally. They illustrate the kind of result you should expect to review; they are not a recording of the hosted skill's output. The authenticated run is covered separately.

The task brief

A good brief gives the agent the data, the claim and the constraints. Without them the agent has to guess, and a plot built on guesses can look right and be wrong.

Plot validation accuracy against training steps for two methods,
Baseline and Example method, from synthetic_accuracy.csv.
Show the mean across 3 seeds with a shaded band for one standard
deviation. Label axes with units. Use direct labels instead of a legend.
Export SVG and PNG. The figure must stay legible when scaled to a
single column. Do not change or add data.

The last sentence matters. Ask the agent to report any data problem it finds, not to repair it.

Environment and dependencies

Python 3 with matplotlib and numpy. The example ran on matplotlib 3.11.2.
Nothing else: no network access is needed to draw the figure.

With the hosted skill, your own agent does the local work, so these libraries must exist on your machine. See agent skills vs MCP servers for what runs where.

The synthetic dataset

Download synthetic_accuracy.csv. It has 42 rows: two methods, three seeds and seven training-step checkpoints. Values are validation accuracy in percent. They come from invented saturating curves plus seeded random noise, produced by make_dataset.py. Do not cite them as measurements.

method,seed,step,val_accuracy_pct
Baseline,0,0,10.0
Baseline,0,500,18.57
Baseline,0,1000,24.75
Baseline,0,2000,35.22

The plotting script

The full script is plot_results.py. These are the lines that decide how the figure reads:

matplotlib.rcParams["svg.fonttype"] = "none"   # keep text as text in the SVG

fig, ax = plt.subplots(figsize=(6.5, 3.6), layout="constrained")
for method, by_step in runs.items():
    ...
    ax.fill_between(xs, mean - std, mean + std, color=c, alpha=0.16, lw=0)
    ax.plot(xs, mean, color=c, lw=2.2, marker="o", ms=4.5, mfc="white", mew=1.6)
    ax.annotate(f"{method}\n{mean[-1]:.1f}%", (xs[-1], mean[-1]), ...)

ax.set_xlabel("Training steps (thousands)")
ax.set_ylabel("Validation accuracy (%)")
ax.set_ylim(0, 90)

The choices have reasons. The band shows spread across seeds, so a reader can see whether the gap between methods is larger than the noise. Direct labels at the line ends replace a legend that would sit on top of the data. Keeping SVG text as text means the labels stay editable and searchable. The y-axis starts at zero so the gap is not exaggerated.

The output

Download accuracy_curve.svg or accuracy_curve.png. The curves are invented, so the figure shows the format, not a finding.

Checks before you use a figure

Run the checks yourself on every figure an agent produces. For this one we checked:

Check	Result for this figure
Axis labels and units	x: "Training steps (thousands)"; y: "Validation accuracy (%)"
Axis ranges	x from 0 to 16; y from 0 to 90, baseline at zero
Values match the data	End labels 78.0% and 69.0% equal the mean of the three seeds at step 16000 in the CSV
Uncertainty shown	Shaded band is one standard deviation across 3 seeds, stated in the figure heading
Synthetic data flagged	The figure heading says "Synthetic example data"
Export size	SVG about 5.6 by 3.7 inches; PNG 1115 by 743 pixels at 200 dpi
Text stays text	The SVG keeps labels as text elements, not outlines

For your own work add the checks that depend on the venue: the column width, font size at final size, colour-blind safe colours and whether the caption states the number of runs. A checklist like this is a review step, not proof of a correct result.

Run it with the skill

The steps below are the supported Claude Code route. The figure above is an illustrative local output. A separate authenticated production run by Codex is documented in the recorded session below; it does not establish that these Claude Code steps were recorded end to end.

Follow how to install Claude Code skills to install the CLI, sign in and register the MCP server.
Install the wrapper:

   skillgild install academic-plotting --agent claude-code

In Claude Code, give the agent your real results file and a brief like the one above, and ask it to use the SkillGild Academic Plotting skill.
Review the script and the figure against the checks, then regenerate with your own corrections.

Read the Academic Plotting listing for its inputs and current allowance. Never ask the agent to invent data to complete a brief.

Limits

A plotting skill can choose a chart type and write the code. It cannot tell whether your experiment was sound, whether a difference is statistically meaningful or whether a journal accepts the style. Those stay your decisions. For more workflows, see the free skills selection guide and the Claude skills overview.

Originally published at skillgild.dev.

How to add skills to Gemini CLI

SkillGild — Tue, 06 Oct 2026 22:03:00 +0000

Gemini CLI discovers skills in ~/.gemini/skills/ (or the ~/.agents/skills/ alias) for your user and .gemini/skills/ (or .agents/skills/) for a workspace. Each skill is a folder with a SKILL.md file. A hosted SkillGild skill uses the same folder, with a wrapper that calls the SkillGild MCP connection for protected capabilities.

Where Gemini CLI looks for skills

Gemini CLI's skills documentation describes four tiers, from lowest to highest precedence:

Built-in skills.
Skills bundled in installed extensions.
User skills in ~/.gemini/skills/ or the ~/.agents/skills/ alias.
Workspace skills in .gemini/skills/ or the .agents/skills/ alias.

When two skills share a name, the higher tier wins. Within one tier, the .agents/skills/ alias takes precedence over .gemini/skills/. That matters if you share a skills folder with Codex, which also reads .agents/skills/.

When a task matches a skill, Gemini CLI asks to activate it and shows a confirmation prompt before it loads the skill's instructions. Expect that prompt the first time a workflow runs.

Add a local skill to Gemini CLI

Create a folder for the skill and a SKILL.md inside it:

your-project/
  .gemini/
    skills/
      review-brief/
        SKILL.md

---
name: review-brief
description: "Check a product brief for missing requirements before coding."
---

Read the brief. List missing inputs and conflicting requirements.
Propose testable acceptance criteria. Ask about open questions before editing files.

In a session, run /skills list to see what was discovered and /skills reload after you add or change a folder. You can also install a skill from a Git repository with gemini skills install <git-url> --consent, and turn one off with /skills disable <name>. This example does not need SkillGild. Copy a downloaded skill's whole folder, because scripts and references can sit beside SKILL.md.

Connect Gemini CLI to hosted SkillGild skills

1. Install the CLI and sign in

Follow Install the CLI. It currently builds from the SkillGild source and needs Go 1.26 or later; prebuilt binaries are listed as coming soon. Then:

skillgild login
skillgild status

Approve the displayed device code in your browser. The credential stays in your operating system's credential store.

2. Register the MCP server

Find the absolute path with command -v skillgild on macOS or Linux, then register the local stdio server. Gemini CLI's MCP documentation gives the syntax gemini mcp add [options] <name> <command> [args...], with a --scope of user or project that defaults to project:

gemini mcp add --scope user skillgild /absolute/path/to/skillgild mcp
gemini mcp list

Use user scope to keep the connection across projects. Inside a session, /mcp shows connection status and discovered tools. No SkillGild API key is pasted into Gemini's configuration.

You can also add the server by hand to Gemini's settings.json under mcpServers, with a command and args, as in the documentation's example.

3. Install a wrapper

skillgild install logo-design --agent gemini-cli

The gemini-cli preset writes ~/.gemini/skills/logo-design/SKILL.md. Run /skills reload, then confirm it appears with /skills list. Read the Logo Design listing for its inputs and current allowance. To pick a different workflow, see the free skills selection guide.

4. Give Gemini a complete task

Use the SkillGild Logo Design skill for a fictional neighborhood bakery
called Morning Loaf. Explore a simple geometric mark that works in one
color and at 16 px. Show the concepts and checks before finalizing files.

For a hybrid skill, the wrapper directs Gemini to start a session, follow the guide, call the hosted tools where needed and end the session. Gemini's own model does the local reasoning and file work; hosted calls handle the protected capabilities. A prompt skill returns a hosted result through skillgild_run_skill.

Check discovery and connection separately

Symptom	What to check
The skill does not appear	Run `/skills list`, check the folder has `SKILL.md`, then `/skills reload`
A skill of the same name behaves oddly	A higher tier or the `.agents/skills/` alias may shadow it; look for duplicates
The wrapper loads but hosted calls fail	Run `gemini mcp list` and `/mcp`, then `skillgild status` in a terminal
The server is missing in another folder	It may have been added with the default project scope; add it again with `--scope user`
A run is rejected	Read the returned error and the listing's allowance; see agent error handling

A wrapper that appears in /skills list does not prove the MCP server is connected. These are two checks.

Other clients

The same SkillGild connection works from Claude Code, Codex CLI and Cursor. The Claude Code install guide compares their folders.

Commands here were checked against Gemini CLI's published documentation and SkillGild's CLI source on October 4, 2026. An authenticated task depends on your own account approval, and we have not published a recorded run.

Originally published at skillgild.dev.

Claude Code video skills: how code-rendered video works

SkillGild — Tue, 06 Oct 2026 22:02:49 +0000

A Claude Code video skill, whether you searched for video generation or video editing, does not generate footage with a video model. It guides your agent to write code, such as HTML, SVG or Rust scenes, and a renderer turns that code into an MP4. That makes the result inspectable and repeatable, and it means your machine usually needs a renderer installed. This guide explains the approach and helps you choose among the five video skills in the SkillGild catalog.

How code-rendered video works

Three steps repeat in every workflow:

Describe the video as code. The agent writes a composition: timed clips, text, motion and audio references.
Preview it. A local preview lets you and the agent check timing and layout before spending render time.
Render it. A renderer steps through the composition and encodes the frames, typically with FFmpeg.

Because the video is code, you can change one line and re-render. Because your agent does the writing, the quality of the result depends on your brief, your assets and your review of the preview.

On SkillGild these skills use hybrid execution: your own agent follows a guide and calls hosted server tools, while rendering and other local work run in your environment. See agent skills vs MCP servers for what runs where.

Compare the five video skills

Requirements below come from each upstream project's own documentation, checked on October 4, 2026. The hosted listing may differ, so read the listing before you install.

Skill	Approach	Upstream requirements	Best for
Brag	Reads your project and builds a short launch video	Node.js 22+, FFmpeg, the HyperFrames CLI	Showing off something you just built
HyperFrames	HTML compositions with seekable animation, rendered to MP4	Node.js 22+, FFmpeg, headless Chrome	Teams that think in HTML, CSS and GSAP
fframes Video	Rust and SVG scenes rendered on the GPU	Rust, a supported GPU, FFmpeg libraries	Developers who want checked, fast renders
Lyric Music Video	Animated graphics synchronised to each sung word	See the listing	A finished song and a recurring visual idea
Video Illustrator	Your narration and real assets plus a chosen style	See the listing	Short promos from your own material

All five are described on their listings as code-rendered or asset-driven. None of these pages claims a particular render time, because that depends on your machine.

Choose by the job

A launch video for a project. Start with the Brag skill. Upstream, it produces a folder with a plan, a composition brief, share copy and an MP4 of roughly 20 seconds in its own example. It needs no live URL, because the agent reads the code.

A video you want to control in HTML. Use the HyperFrames skill. Upstream describes compositions as HTML with data attributes for timing, rendered by seeking each frame in headless Chrome, so the same input gives the same video. It is Apache 2.0 licensed.

A video where you want automatic checks. Use the fframes Video skill. Its documented commands include inspect, which validates frames without a full render, and render --draft for a quick half-resolution preview. It requires Rust and GPU support (Metal on macOS, Vulkan on Linux and Windows).

A music video or a narrated promo. Use the Lyric Music Video skill for a finished song, or the Video Illustrator skill for narration over your own assets. For a few seconds of animation people can save to their phone, LiveCanvas turns a topic into an Apple Live Photo info card. Check each listing's inputs and licensing of any media first.

Prepare before you ask

Video fails most often on inputs, not on the skill. Before you start:

Assets you may use. Use images, logos, music and footage you have the right to publish. A skill cannot clear rights for you.
A script or story. One sentence on the audience and the single thing they should remember.
Format. Aspect ratio, length and where it will be posted.
Local tools. Confirm Node.js, FFmpeg or Rust as the skill requires, then run the skill's preview before a full render.

Run one end to end

Follow how to install Claude Code skills to install the CLI, sign in and register MCP.
Install a wrapper, for example:

   skillgild install brag --agent claude-code

Ask Claude Code with a complete brief:

   Use the SkillGild Brag skill on this repository. Make a 20-second launch
   video for developers. Tone: calm and confident. Use only assets in this
   repo. Preview before rendering and tell me what you could not verify.

Watch the preview, correct timing and text, then render.

The commands follow SkillGild's CLI presets. We have not published a recorded authenticated render for these skills, and nothing here is a benchmark of speed or quality. Compare output on your own task before relying on one skill.

Next steps

Read the free skills selection guide for the whole catalog, or the Claude skills overview if you are new to skills.

Originally published at skillgild.dev.