DEV Community: SkillGild

Impeccable vs Taste Skill: which Claude design skill to use, tested

SkillGild — Tue, 13 Oct 2026 17:53:52 +0000

Short answer: pick Taste Skill for a clean landing page at a modest cost, and Impeccable when the page has to be memorable, has to stay truthful about your product, or is an app or dashboard rather than a marketing page. In our test on the same brief, Taste Skill produced a calm, tidy page for $2.28 in 7 minutes; Impeccable produced a far bolder page, and the only one that invented no product facts, for $7.49 in 24 minutes.

Both are among the most popular design skills for Claude Code, Codex and Cursor, and people often ask which to install. They solve the same problem, generated pages that all look alike, in very different ways. This page compares them on what they are, what they produced from one brief, what they cost and which jobs each one suits.

Impeccable vs Taste Skill at a glance

	Impeccable	Taste Skill
Author	Paul Bakaus	Leonxlnx
GitHub stars (13 October 2026)	80.7k	95.5k
License	Apache-2.0	MIT
What it is	A design language: 24 commands, about 40 playbooks, an anti-pattern detector and a small engine binary	One long SKILL.md of rules (about 1,200 lines)
How it steers the design	Picks a mode, writes PRODUCT.md, rolls a seeded concept, builds, audits, writes DESIGN.md	States a "design read", sets three dials, follows banned-pattern rules, runs a pre-flight check
Built for	Any interface: landing pages, apps, dashboards, docs, showcases	Landing pages, portfolios and redesigns (not dashboards)
Commands	`/impeccable shape`, `audit`, `critique`, `polish`, `bolder`, `quieter`, `animate` and 17 more	None; it applies to the whole task
Install	`npx impeccable install`	`npx skills add https://github.com/Leonxlnx/taste-skill --skill "design-taste-frontend"`
On SkillGild	Impeccable	Taste Skill

The test: one brief, both skills

We gave Claude Code the same brief for each run: the landing page for Ledgerline, a fictional bookkeeping app for freelance designers, with a hero, three steps, features, one $12 plan, an FAQ and a footer. It had to be one self-contained HTML file with Google Fonts as the only external resource, and it could not invent testimonials, customer counts, logos or awards. Both runs used Claude Code 2.1.278 with Claude Opus 5 on 9 October 2026, with the skill's files in the project and the Skill tool switched off so no other installed skill could interfere. Each skill ran once, so this is an honest example rather than a benchmark; a second run would produce different pages.

Both pages from the same brief, scrolled side by side (13 seconds, no sound). Watch it on skillgild.dev.

What each skill did before writing code

Impeccable ran its context command, found no product file, and wrote a PRODUCT.md that separates what the brief said from what it did not. It listed the unknowns explicitly ("which banks… data export… card-required-or-not… must not be invented"), then rolled a seeded concept from a shortlist grounded in the subject. It landed on a Swiss departure board: money arriving and leaving as a timetable, with the quarterly tax date as the next departure.

Taste Skill declared its design read in one line ("SaaS landing for solo freelance designers… with a calm, type-led, honest-tool language"), set its dials to variance 7, motion 5 and density 4, lowering variance "because this is a money app and trust matters", and resolved two conflicts with the brief in writing: no icon library, and a working mini-product in the hero instead of a fake screenshot.

The two heroes at 1440 px.

Results

	Impeccable	Taste Skill
Direction	Swiss departure board, signal yellow and graphite	Calm, near-monochrome, one ink-blue accent
Typefaces	Barlow Condensed and Barlow	Outfit and IBM Plex Mono
Visible words	About 890	About 460
Spaced em dashes	0	0
All-caps labels	Throughout, as the board style	0
Headline treatment	A smaller second line, "Not in a spreadsheet."	One word, "spreadsheet", in blue
Horizontal scroll at 375 px	None	None
Sample data labelled as examples	Yes ("Example board")	Yes ("Example transactions")
Invented product facts	None	Read-only bank link, receipt capture, CSV and PDF exports, email support, 30 days to export after cancelling
Impeccable detector findings†	8	3
Missed its own checks	No	Headline ran to 3 lines and the hero floats low at 1440 px, against its own pre-flight
Turns	46	13
Time	23.8 minutes	7.1 minutes
API-equivalent cost (reported by Claude Code)	$7.49	$2.28

†Impeccable's own anti-pattern detector, run on both finished pages, leaving out its cramped-padding rule (false positives on pages that compute padding with calc()) and its design-system rules (which only apply to a page with its own DESIGN.md). With every rule counted: 55 and 6. Most of Impeccable's remaining findings are all-caps body text, which is its departure-board style rather than an oversight.

For reference, the same brief with no skill cost $0.98, took 3.3 minutes, invented similar product facts and was the only page that scrolled sideways on a phone.

Both pages at 375 px.

Where Impeccable wins

It doesn't make things up. Its rule "Ask before replacing factual copy or adding claims", and the PRODUCT.md it writes when it cannot ask, kept every unsupported claim off the page. For a real product, this matters more than any visual difference: an invented "no card needed" or a list of supported banks can mislead buyers.
A memorable direction. The departure-board concept turns the product's idea into the page. Taste Skill's page is good; Impeccable's is the one you remember.
It covers more jobs. Four modes (persuade, operate, read, experience) and 24 commands mean it works on dashboards, settings screens and docs, and on existing interfaces: /impeccable audit and /impeccable critique review what you have without rebuilding it.
It leaves a design system behind. The DESIGN.md it writes keeps later changes consistent.

Where Taste Skill wins

Cost and speed. About a third of the cost and a third of the time for a finished landing page.
Stricter about generic tells. It bans the em dash outright, rations the middle dot and lists dozens of AI-design patterns to avoid. Its page had none of the template chrome the no-skill page used.
Restraint. A calm, readable page that suits a finance product and would pass most brand reviews. Impeccable's condensed capitals and split-flap tags are bolder but slower to read.
Simplicity. One file you can read in an evening and adjust. No binary, no commands to learn.

Its two weak points in our run: it invented product facts like the other skills, and it missed two items from its own pre-flight check. Both are reasons to review its output, not reasons to avoid it.

Which should you use?

Your job	Pick
A landing page or portfolio on a budget	Taste Skill
A launch page that has to stand out	Impeccable
A real product where every claim must be true	Impeccable, or Taste Skill with the facts spelled out in your brief
A dashboard, settings screen or app UI	Impeccable (Taste Skill says this is out of scope)
Reviewing or polishing an existing interface	Impeccable's `audit`, `critique` or `polish`
You want rules you can read and tweak	Taste Skill

Can you use both? Not on the same page at once: their rules overlap and sometimes disagree, so one direction skill per page works best. A combination that makes sense, though we did not test it here, is building with Taste Skill and then running Impeccable's audit command on the result.

Whichever you choose, put the real product facts in your brief. It was the single biggest difference between a page you could ship and one you would have to rewrite.

Install both

# Impeccable: detects your agents, then run /impeccable init inside the agent
npx impeccable install

# Taste Skill
npx skills add https://github.com/Leonxlnx/taste-skill --skill "design-taste-frontend"

# Or either one from SkillGild, for Claude Code, Codex, Cursor or Gemini CLI
skillgild install impeccable --agent claude-code
skillgild install design-taste-frontend --agent claude-code

Read the full tests: Impeccable and Taste Skill. For eight more frontend skills, including Anthropic's frontend-design skill (the best all-round default in our test), see the top 10 Claude frontend and design skills.

Originally published at skillgild.dev.

10 Claude Code Skills I Actually Use Through SkillGild

SkillGild — Thu, 08 Oct 2026 21:05:36 +0000

By Niloy Nath, sharing my experience as a SkillGild consumer.

I use Claude Code skills through SkillGild for frontend work, code review, and getting finished work out into the world. Paying for the skills I keep returning to has been one of my best decisions for this workflow. Vernier is the clearest example.

I'm writing this as a SkillGild consumer. This is my personal Claude skills shortlist, based on the work I want my agent to do. My list includes two paid skills and eight free ones; I checked the current catalog on October 9, 2026.

My work covers backend systems and AI infrastructure, so I care about the implementation and the checks around it. I want a skill to leave me with something I can inspect and use in a project.

If you only want the short answer: I pay for the parts that solve a recurring problem, then add free skills around them. A paid skill earns its place when I can explain what I use it for without reciting its feature list.

The Claude Code skills I use, at a glance

Skill	What I use it for	Current access
Vernier	Interactive illustrations for product interfaces	SkillGild Pro
Pro Preview	Checking color contrast before shipping	SkillGild Pro
Taste Skill	Frontend layout and visual direction	Free hosted skill
Logo Design	SVG marks and brand concepts	Free hosted skill
Brag	Turning project work into a launch video	Free hosted skill
HyperFrames	Controlling the video composition and timing	Free hosted skill
OpenSpec Propose	Defining a feature before implementation	Free hosted skill
Code Review	Reviewing a diff for concrete problems	Free community plugin
Webapp Testing	Checking an app in a real browser	Free hosted skill
Academic Plotting	Research figures and readable chart colors	Free hosted skill

The order follows my workflow and preferences. It isn't a benchmark ranking. The original creators are credited below; getting a skill through SkillGild doesn't make it a SkillGild invention.

What are Claude Code skills?

Claude Code skills are folders containing a SKILL.md guide and, when needed, scripts or reference files. Claude loads relevant instructions to help with a task. A skill can describe a local workflow or teach your agent how to use a hosted service such as SkillGild.

1. Vernier: the paid Claude Code skill I value most

AI-generated editorial concept illustrating the interaction model; see the linked skill examples for actual Vernier output.

Vernier is my first pick when I want an interface illustration that responds to the person using it.

The useful part is the interaction model. Vernier makes isometric line illustrations that can respond to a pointer, touch, keyboard input, or a live signal. The deliverables include a React component, a web component, and a preview page. That fits the kind of product interfaces I work with much better than treating every visual as a static image.

For example, I'd give the agent this brief:

Use Vernier to design an isometric illustration for a developer tool. Show one reading from 0 to 1. Give it pointer, touch, and keyboard controls, and keep the highlight consistent with the interface accent.

That is a specific job with an output I can inspect. It's why paying for Vernier feels worthwhile to me: I want a reusable way to build this kind of interaction, rather than spending every session explaining the same behavior again.

I also respect its limits. Vernier isn't the choice for a photograph, a logo, or a chart with several data series and axes. It shows one reading at a time. If the requirement is a line chart comparing experiments, I move to Academic Plotting.

My recommendation: if interactive product graphics are part of your regular work, look at Vernier's examples and requirements, then compare the current Pro plans. This is where I'd start with a paid skill.

2. Pro Preview: a paid check I can use before shipping

I use Pro Preview for a quieter problem: colors that look acceptable in a screenshot but don't have enough contrast in the interface.

It checks a palette against WCAG contrast ratios and suggests alternatives that pass the requested checks. That gives me something concrete to review when an agent changes the colors in a dashboard, slide, or chart.

The distinction matters with charts. A color can be readable as a thick line and still fail when used for a small text label. WCAG's minimum contrast guidance explains the text requirements; I don't want to decide that by eye.

My prompt is usually closer to this than to “make the colors accessible”:

Check these foreground and background pairs. Separate small text from larger graphical elements, explain which checks fail, and propose replacements that preserve the meaning of the palette.

A contrast check covers contrast. I still need to inspect keyboard navigation, labels, focus states, and the rest of the interface. Pro Preview earns its place by giving me a bounded check I can repeat.

At publication, Vernier and Pro Preview are the two premium skills listed in SkillGild Pro, each with 25 sessions per calendar month. Prices and the payment method depend on billing country. I use the pricing page for the current terms rather than copying a price that may change.

3. Taste Skill: frontend direction before more components

Taste Skill, credited to Leonxlnx, is one of the free Claude Code skills I keep around for frontend work.

I use it when a page technically works but still feels like the agent assembled whatever layout it reached for first. Giving the agent a brief and a visual direction is more useful than asking for another round of decorative changes.

My brief names the audience, the main action, the content that must remain, and the existing design system. For an established page, I want an audit before a redesign. The skill helps establish that sequence.

I don't apply it indiscriminately to every component. If the task is to fix an indexing directive, the best result may be a two-line change. A design pass should serve the page, not turn a small repair into a new website.

SkillGild's Taste Skill walkthrough is a useful way to see the kind of brief and output involved before installing it.

4. Logo Design: give the mark constraints

I use Logo Design, by kaankiziltug, when I need a mark I can use in an actual interface.

The output being an SVG matters. I want to inspect the geometry, try it at a small size, and see what happens in one color. A polished concept board alone doesn't answer those questions.

The brief needs to name the product, the intended audience, and where the mark will appear. I also specify restrictions early: whether text belongs in the mark, how it should read at 16 pixels, and which visual ideas to avoid.

This is a good companion to Taste Skill. One helps establish the page's visual direction; the other focuses on the mark. I keep those tasks separate so the agent doesn't redesign everything while solving a logo problem.

5. Brag: turn finished project work into something shareable

Brag, by Shunit Haviv Hakimi, is the skill I reach for when the project exists and I want to show it to someone.

Its starting point is the code. The agent reads the project and builds a launch-video workflow around what is there, which is useful before I have a polished live demo ready.

One of my launch-video projects needed a 90-second film with separate desktop, mobile, and social cuts. That made the brief important: the audience, the story, and what the product could actually do had to be explicit. A skill gives the agent a method; I still have to give it the right project facts.

I use Brag for the launch-film task, and check the resulting scenes against the product. Screens that imply features the app doesn't have would make the video worse, however good the animation looked.

You can watch a creator-provided Brag example before deciding whether it fits your project.

6. HyperFrames: when I need control over the video

HyperFrames, by HeyGen, is where I go deeper into the composition.

The workflow uses HTML with timed clips and animation, then renders to video through the HyperFrames CLI. It suits me because I can work with the composition as code: change a scene, review a frame, and adjust the timing.

The practical lesson from the launch-video work is to treat the mobile version as its own composition. A desktop frame cropped into a vertical rectangle can lose the words or UI that made the shot useful.

I use Brag when I want the project-to-launch-film workflow. I use HyperFrames when I need to work on the underlying composition and render. They cover different stages of the same job.

This is still a local rendering workflow. Check the renderer requirements and installation steps on the skill page before assuming the skill alone can produce an MP4.

7. OpenSpec Propose: write down the change before writing code

I use OpenSpec Propose, by Fission AI, when a feature has enough moving parts that a casual prompt leaves room for several different implementations.

The skill produces a proposal, specification changes, a design, and implementation tasks grounded in the project's existing specs. I want those artifacts to state what will change and what a working result looks like.

A useful prompt includes the trigger and the expected behavior. “Improve billing” is too broad. “After a successful payment, attach the purchase to the account using the checkout email, and make repeated callbacks safe” gives the proposal something to resolve.

I skip the ceremony for small repairs. For changes that cross a frontend, an API, and stored state, writing the agreement first is worth the effort.

The OpenSpec guide covers the workflow in more detail.

8. Code Review: ask for findings I can verify

Code Review is Anthropic's official plugin, listed as a free community skill through SkillGild. Its upstream source remains the place to inspect the plugin itself.

I use it after a meaningful change, with a narrow request: review the diff for correctness, project conventions, and the behavior the task required. I want a location and a reason for each finding.

An agent saying “the code looks good” doesn't give me much to work with. A finding that identifies an incorrect condition and explains the case it mishandles is something I can check.

I still verify the findings. A review can miss a bug or report a false positive. The value is another structured pass over the change before I call it finished.

9. Webapp Testing: the browser gets a vote

I use Webapp Testing, from Anthropic's skills repository, to check the interface in a real browser.

This matters because a build can pass while a link is covered by another element, an image fails to load, or a mobile layout overflows. Those are observable failures, and I want the agent to bring back the browser evidence.

For video watch pages, the check needs to include playback and the links that take someone to the page. For a form, it needs the submit path and the states a person can actually reach. I name the flow instead of asking the agent to “test everything.”

I usually include desktop and mobile viewport sizes in the brief. A screenshot helps, but clicking the control and checking its result is the part I care about most.

10. Academic Plotting: figures that survive being read

Academic Plotting is credited to Orchestra Research. I use it when the output is a chart for a technical explanation, paper, or research result.

The task starts with the data and the comparison I want a reader to understand. Then I can ask for the chart type, plotting code, and the checks needed for the intended output size.

SkillGild's recorded plotting walkthrough gives a concrete example: the original colors passed the graphics contrast check but failed the small-label check. The revised colors returned ratios of 5.14:1 and 5.60:1 against white. The run uses a synthetic dataset and was performed with Codex; it isn't a claim about a Claude Code experiment.

That example captures why I keep a plotting skill around. A chart can look fine at full screen and become unreadable in a document. I want the agent to consider the final figure size while it writes the code.

How I install these Claude Code skills through SkillGild

Once the SkillGild CLI is installed and connected, the command format is:

skillgild install vernier --agent claude-code
skillgild install pro-preview --agent claude-code
skillgild install design-taste-frontend --agent claude-code

Replace the slug with the skill you want. The Claude Code installation guide covers setup; the individual listing tells you whether the skill is hosted or installed from an upstream repository.

For hosted skills, installation puts the guide into the agent's workflow; an account and the required entitlement are still needed to start a session. Installing a wrapper doesn't unlock a paid skill. Your coding agent also keeps using its own model and subscription.

Anthropic's skill documentation explains Claude Code's personal and project skill locations. I use project scope when a workflow belongs to a repository, and personal scope when I want it across projects.

Are Claude Code skills free?

Some are free; some require a paid service or plan. On SkillGild, the current listings distinguish free hosted skills, free community skills, and Pro skills. Hosted session allowances and local execution are different things, so I check the listing rather than treating every installation as a paid run.

The eight free skills above don't require a Pro purchase just because Vernier and Pro Preview do. Any costs for your agent's model, renderer, or other services are separate.

Is it worth paying for Claude Code skills?

For me, yes, when the paid skill matches work I return to. Paying for Vernier has been one of my best decisions for this part of my workflow. I know the kind of visual interaction I want it to help build, and I can inspect what it produces.

I wouldn't buy a plan just to have a bigger skills list. If you mainly need code review and browser checks, start with the free skills. If you repeatedly need interactive product illustrations or the premium contrast-checking tools, compare SkillGild Pro.

Which Claude Code skills would I start with?

My starting pair would be Vernier for the interactive visuals I care about, and Webapp Testing to check the interface I ship. If the immediate task is a landing page, I'd add Taste Skill. If it's a launch video, I'd add Brag.

Pick the job first. Then open the relevant SkillGild listing, check what the skill needs, and give it a real brief. That is the part of using skills that has been most helpful to me.

Originally published on my portfolio.

Best Claude skills for marketing, SEO and ads in 2026

SkillGild — Thu, 08 Oct 2026 20:36:46 +0000

Marketing work is where Claude skills pay off fastest, because most of the job is repeatable method: the same audit, the same brief, the same editing pass, run against different inputs. A skill captures that method once so you stop re-explaining it.

This page lists the Claude skills marketers actually use, grouped by the job. Some are large sets that cover a whole function; most do one thing well. Every pick links to its SkillGild listing, where the install command, author and license are shown.

Once the SkillGild CLI is set up, each one installs with a single command:

skillgild install <slug> --agent claude-code

Use --agent codex, cursor or gemini-cli for other clients. If you want the wider picture rather than the marketing cut, start with the best Claude Code skills list.

Start with one of the two large sets

Two skills cover most of a marketing function on their own. Install one of these before anything else; the single-purpose skills below fill the gaps.

Marketing Skills by Corey Haines. Sixty-plus marketing skills in one set: copywriting and copy editing, conversion work on landing pages, signup flows, forms, popups and paywalls, SEO audits and programmatic SEO, paid ads, email sequences, pricing, A/B test planning, analytics tracking, cold email, onboarding, referrals, RevOps and sales enablement. It is the broadest marketing collection available and the one to install first if you only install one.

Claude SEO by Agrici Daniel. Twenty-six sub-skills and nineteen specialist sub-agents aimed squarely at search: technical audits, content quality, schema, E-E-A-T, local and e-commerce SEO, hreflang, backlinks, sitemaps, image optimisation, and generative-engine readiness including llms.txt and WebMCP. If search is the channel you own, this goes deeper than the SEO portion of a general marketing set.

The two overlap on SEO audits. Running both is fine — they are instructions, not services, so there is no conflict — but expect to pick a favourite for audits and keep the other for everything else.

Copywriting and editing

Drafting is the part people reach for first and the part that most needs a second pass. These three run in sequence: draft, strip the tells, check against a style guide.

Humanizer by blader. Rewrites AI-sounding copy so it reads like a person wrote it, working from the patterns catalogued in Wikipedia's guide to AI writing, then audits its own output. The most-searched community skill of the year, and the one that matters most if you publish at volume.

Stop Slop by Hardik Pandya. Seven rules that remove the recognisable tells: not-X-but-Y contrasts, staged openers, forced triads, filler closers. Many people run it as the final pass after Humanizer rather than instead of it.

Writing Guidelines by Vercel. Reviews prose against more than eighty rules from Vercel's style guide. Built for documentation and product copy, so it is the right choice for help centres, onboarding emails and UI strings, and the wrong one for a landing page headline.

Ad, social and brand creative

Creative is the other half of paid and social work, and it is the half that usually blocks a launch.

Nano Banana by Keanan Koppenhaver. Generates and edits images from a plain prompt using Google's Gemini image models: ad variants, social crops, icons, photo cleanup and sequential story images. Bring your own Gemini API key.

Canvas Design by Anthropic. Composes finished visual artefacts — posters, covers, social graphics — on an HTML canvas with deliberate typography, grid and colour choices instead of filling a template. Use it when the output needs to look designed rather than generated.

Logo Design is a hosted skill that takes a brand brief to production files: concepts, geometric SVG, tests at small sizes and in one colour, then presentation boards. It runs through SkillGild with free monthly runs, so it is the cheapest way to see whether hosted skills suit your workflow.

Research and positioning

The work before the writing: what the market is talking about, and what you are actually claiming.

last30days by mvanhorn. Researches a topic across Reddit, X, YouTube, Hacker News, Polymarket, GitHub and the web for the last thirty days, ranks what people actually upvoted and shared, and returns a grounded summary. Useful for campaign timing and for finding the phrasing your audience already uses.

Deep Research runs longer, multi-source investigations and is the better fit for competitor and category work where you need citations rather than a pulse check.

Grill Me by Matt Pocock. Interviews you about a plan one question at a time, each with a recommended answer attached, until every branch is resolved. It was built for engineering decisions and works just as well on positioning: it surfaces the claims you have not decided yet before they reach a page.

How to install a marketing skill

Marketing skills are ordinary skill folders, so nothing about installing them is special. The short version:

skillgild install marketing-skills --agent claude-code
skillgild install claude-seo --agent claude-code

Then start a new session and describe the job in your own words — "audit this landing page for conversion" — without naming the skill. Claude says when it uses one. If nothing happens, the folder is in the wrong place or the skill's description does not match your phrasing; the install guide covers both.

A note on the large sets: because Marketing Skills and Claude SEO each bundle dozens of sub-skills, they take more of the model's attention than a single-purpose skill. If you work on one channel, installing the specific skills you need usually beats installing everything.

How these were chosen

Each pick does a marketing job that recurs, is maintained by a named person or organisation, and has a public repository or a hosted listing with its license stated. We read the README and the SKILL.md before listing any of them; where a listing says the license is not stated, the repository had no license file at review time, so treat the code as all rights reserved until one is added.

Marketing demand for skills is also the most commercially-minded segment of the whole category — roughly a third of marketing-related skill searches carry commercial intent, against single digits for the ecosystem overall. That is the main reason this list exists as its own page rather than a section somewhere else. The search data behind that claim is in the state of Claude skills.

Community skills run locally in your agent on your own model usage; SkillGild lists them, credits their authors 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 of Claude Code skills.

SkillsMP vs SkillGild: an index of everything, or a catalog you can install

SkillGild — Thu, 08 Oct 2026 20:36:25 +0000

Short answer: these are not the same kind of product, and the usual "which is cheaper" question does not apply. SkillsMP is a free index: it collects SKILL.md files from public GitHub repositories and helps you find them, then sends you to the original repository. SkillGild is a reviewed catalog: far fewer skills, but each one has a checked author, license and source, a one-command install for your agent, and hosted skills that run on our servers with a free monthly allowance. Use SkillsMP to discover what exists; use SkillGild when you want to install something and know what you are installing.

We publish SkillGild, so read this as a comparison from one side. Every SkillsMP fact below comes from its own public pages, checked on 9 October 2026 and linked where it is used. We have not benchmarked search quality on either service.

SkillsMP vs SkillGild at a glance

	SkillsMP	SkillGild
What it is	"An Open Map of the Agent Skills Ecosystem"	A reviewed marketplace with hosted and community skills
Catalog size	Claims "3M+" SKILL.md files from public GitHub repositories	Tens of skills, each read before listing
How entries arrive	Collected from public repositories	Reviewed one at a time: author, license, source, `SKILL.md`
Install path	None described in its docs; it links you to the source	`skillgild install <slug> --agent claude-code`
Agents named	Claude Code, Codex CLI, ChatGPT	Claude Code, Codex, Cursor, Gemini CLI
Hosted execution	No	Yes, for hosted skills, through the SkillGild MCP server
Price	"completely free", "No paid tiers"	Free skills with 25 runs a month; Pro from $6.99 a month
Programmatic access	REST API and an MCP endpoint	MCP server, CLI and SDKs
Who runs it	"an independent community project", written in the first person	A company, with refunds, support and a creator program

SkillsMP's description of itself, its "3M+" figure and the languages and occupation counts come from its home page and about page; the absence of an install path is from its documentation. SkillGild's prices are shown for your country, as on our pricing page.

The real difference is review, not price

SkillsMP is free and says so plainly: its home page describes the service as "completely free" with "No paid tiers", funded by donations. There is no subscription to compare against, so a pricing table would tell you nothing useful.

What differs is what happens between a skill existing and you running it.

SkillsMP indexes at scale and hands you back to the source. Its about page says the project exists to "Collect 3M+ SKILL.md files from public GitHub repositories" and to "Show creators, repositories, and source links". It is explicit that it does not vet what it collects: the same page says SkillsMP "does not rush to judge skills", and it tells readers to "Return to the real source before deciding whether to install or reuse anything" and to "Always review code before installation". That is honest, and it puts the review work on you.

SkillGild reviews before listing. A skill reaches our catalog only after someone has read its README and its SKILL.md, confirmed the author and the repository, and recorded the license, including an honest "not stated" when the repository has no license file. Community skills are listed and installed from their own repositories, never copied or re-hosted, and the author is credited on the page. That is why our catalog is measured in tens rather than millions.

Neither approach is wrong. An index of three million files answers "does something like this exist?". A reviewed catalog answers "can I install this one safely, and what am I agreeing to?".

Installing: one command against a trip to GitHub

This is the most practical difference.

SkillsMP's documentation describes no installation method at all, and points to Anthropic's own documentation instead: "For detailed guides on how to install and use Skills, please refer to the official documentation". Once you have found a skill there, you open its repository and copy the folder into your agent's skills directory yourself.

On SkillGild, every listing carries a working command:

skillgild install humanizer --agent claude-code

Use --agent codex, cursor or gemini-cli for other clients, and the CLI writes to the right directory for each. The install guide covers folder paths, global against per-project installs and what to check when a skill does not load.

If you prefer the manual route, it works the same from either source: a skill is a folder containing a SKILL.md, and copying it into ~/.claude/skills/ is enough.

Running a skill: local files against hosted tools

Every skill SkillsMP indexes is an open-source folder that runs locally in your agent, on your own model usage. SkillGild lists those too, on exactly the same terms.

SkillGild also has a second kind. A hosted skill installs a small wrapper, and the work runs on our servers through the SkillGild MCP server. That keeps a creator's private prompts and server-side tools off your machine, lets tools improve without a reinstall, and counts runs against a monthly allowance. The run modes page explains both. An index of public repositories has nothing equivalent, because there is nothing to host.

Programmatic access

Both services are built to be queried by agents rather than only by people.

SkillsMP publishes a REST API and an MCP endpoint. Its home page states the limits: 50 requests a day anonymously, 500 a day with a free API key, and MCP access with no API key and no daily quota, subject to shorter per-IP limits.

SkillGild's MCP server serves the catalog and runs hosted skills, and there are open-source SDKs for TypeScript, Python and Go, covered in the agent skills SDK guide. The difference matches the products: SkillsMP's API returns pointers to repositories, and SkillGild's runs the skill.

Which to use

Finding out whether a skill already exists for some job. SkillsMP, by a wide margin. Nothing else indexes the ecosystem at that scale, and it is free.
Installing something today and knowing what it is. SkillGild, because the author, license and source have been checked and the install is one command. Or SkillsMP plus your own review of the repository, which is the same work done by hand.
Running a skill without putting its code on your machine. Only SkillGild's hosted skills do this.
Browsing by job rather than by name. Both, differently: SkillsMP organises by occupation and category across everything it has collected; SkillGild's best Claude Code skills and category pages are editorial picks with reasons attached.

Most people end up using both, and that is a reasonable outcome. They answer different questions.

How we checked this

Every SkillsMP claim above is quoted from its home page, about page or documentation on 9 October 2026, and linked where used. We did not test its search quality, measure its index, or verify the "3M+" figure independently; it is the figure the site publishes. Third-party write-ups quote wildly different counts for SkillsMP, from twenty-five thousand to several hundred thousand, which is one reason we cite only the site's own number and the date we read it.

We have not compared the two on anything we cannot show you. There is no measured winner here on search relevance or catalog quality, and a comparison written by one of the two parties should not be the only thing you read. The wider survey is in best AI agent skill marketplaces, and the closest comparison to this one is Skillry vs SkillGild, where both services do charge and a price comparison is meaningful.

Humanizer vs Stop Slop: which removes AI writing tells?

SkillGild — Thu, 08 Oct 2026 20:36:04 +0000

Short answer: they do different jobs, and most people who care about this run both. Humanizer rewrites AI-sounding prose so it reads like a person wrote it, without changing what it says. Stop Slop is a shorter, stricter rule set that deletes the specific tells a model leaves behind. Humanizer changes how a draft moves; Stop Slop removes what should not be there. Running Humanizer first and Stop Slop last is the common order.

Both are free, open-source community skills, listed on SkillGild and installed from their own repositories. Neither is ours.

What each one actually does

Humanizer by blader rewrites AI-sounding text so it reads like a person wrote it, without changing what it says. It works from the patterns catalogued in Wikipedia's guide to AI writing, then audits its own output against the same list. It is the most-searched community skill of the year, which is a reasonable proxy for how widely the problem is felt.

Stop Slop by Hardik Pandya is a skill file that teaches the model to recognise and remove its own writing tells: throat-clearing openers, not-X-but-Y contrasts, forced triads, filler closers. It is seven rules rather than a rewriting method, which is why it is quick and why it rarely changes your meaning.

The distinction matters because the two failure modes are different. A draft can be free of every obvious tell and still read like a machine wrote it, because the sentences are all the same length and every paragraph has the same shape. That is Humanizer's problem to solve. Equally, a well-paced draft can still open with "In today's fast-paced world" and close with "the possibilities are endless". That is Stop Slop's.

Side by side

	Humanizer	Stop Slop
Author	blader	Hardik Pandya
What it changes	Rhythm, sentence variety, cadence	Specific phrases and structures
Method	Rewrites, then audits its own output	Seven rules applied to the draft
Risk to your meaning	Higher: it rewrites sentences	Lower: it mostly deletes
Length of pass	Slower, it reworks the text	Fast
Best used	First, on a full draft	Last, as a final check
License	MIT	MIT

Both install the same way once the SkillGild CLI is set up:

skillgild install humanizer --agent claude-code
skillgild install stop-slop --agent claude-code

Use --agent codex, cursor or gemini-cli for other clients.

Running them in sequence

The order people settle on is draft, Humanizer, Stop Slop, read it yourself.

Write or generate the draft. Neither skill helps with a draft that has nothing to say; they change how it reads, not what it argues.
Humanizer. Expect sentences to be recombined and paragraph shapes to change. Read the output against your original, because a rewriting pass is the step most likely to lose a qualifier that mattered.
Stop Slop. Expect deletions and small substitutions rather than rewrites. This is the pass you can run with more confidence.
Read it aloud. Both skills are working from lists of known patterns. Neither knows your subject, your reader or what you actually meant.

Running Stop Slop first is not wrong, but it wastes work: Humanizer's rewriting can reintroduce a filler closer that Stop Slop had already removed.

What neither skill does

Be clear about the limit, because the category attracts overclaiming.

These skills change prose style. They do not make text undetectable by AI-detection tools, and no skill honestly can: detection tools disagree with each other, change without notice, and produce false positives on human writing. If your reason for using one of these is to pass a detector, that is not a promise either project makes and not one we would repeat.

They also do not check facts. A humanised paragraph with a wrong number in it is a wrong paragraph that reads nicely. If accuracy is the problem, that is a different pass.

Other skills in this area

Writing Guidelines by Vercel is the third option worth knowing, and it solves a different problem again: it reviews prose against more than eighty rules from Vercel's style guide. It is built for documentation and product copy, so it is the right choice for help centres, onboarding emails and UI strings, and the wrong one for an essay.

A fourth project, Caveman, takes the opposite approach: instead of smoothing prose it compresses it to terse, almost telegraphic output. It is popular and often mentioned alongside these two, but its repository restricts use of its name, so it is not listed on SkillGild and we link to it only in passing. Read its own repository and license before installing it, as you would with anything you find on GitHub.

For the wider set, see the best Claude Code skills roundup, or best Claude skills for marketing if you are editing copy at volume and want the surrounding SEO and creative skills too.

How we chose these

Both skills are open source under the MIT license, maintained in public repositories by named authors, and widely enough used that people search for them by name. We read each repository's README and SKILL.md before listing it, and both are installed from their own repositories rather than copied onto SkillGild. We have not run a controlled comparison of output quality between them, and this page does not claim one is better: they are different passes, and the sequence above is what their own documentation and common use suggest. Both appear in the catalog of Claude Code skills.

Impeccable skill for Claude Code: 24 design commands, tested

SkillGild — Thu, 08 Oct 2026 19:53:24 +0000

Impeccable by Paul Bakaus is the most complete design skill for coding agents, and the most ambitious. Where most design skills are one SKILL.md of advice, Impeccable is a design language: 24 commands to shape, build, critique, audit and polish an interface, about 40 reference playbooks, a deterministic detector for generated-design anti-patterns, and a small engine binary the agent calls for context. Its repository had about 79,000 stars on 9 October 2026.

We ran it on a real brief beside a run with no skill and runs with three other design skills. It produced the boldest page of the five, and it was the only run that did not invent facts about the product. It was also by far the slowest and most expensive. Here is what it is, how to install it, and what happened.

What Impeccable gives your agent

A command for each design job. The SKILL.md lists them by category:

Category	Commands
Build	`shape` (plan the UX before code), `init` (record product context in PRODUCT.md), `document` (write DESIGN.md from existing code), `extract` (pull tokens and components into a system)
Evaluate	`critique` (UX review with heuristic scores), `audit` (accessibility, performance, responsive checks)
Refine	`polish`, `bolder`, `quieter`, `distill`, `harden` (errors, i18n, edge cases), `onboard`
Enhance	`animate`, `colorize`, `typeset`, `layout`, `delight`, `overdrive`
Fix	`clarify` (UX copy), `adapt` (devices and screen sizes), `optimize` (UI performance)
Iterate	`live` (pick elements in the browser and try alternatives), `generate` (variants of a named element)

Run one as /impeccable audit, /impeccable bolder hero and so on, or just describe the design work and let it route.

Four modes. It decides what success means for the surface first: Persuade (landing and pricing pages: the visitor acts), Operate (app UI and dashboards: the visitor completes a task), Read (docs and articles) or Experience (portfolios and showcases).

Rules about truth. "The brief wins" over Impeccable's own taste, and "Ask before replacing factual copy or adding claims." When it cannot ask, it writes down what it inferred and what it does not know. That rule turned out to matter more than anything else in our test.

A detector and an engine. impeccable context loads PRODUCT.md, DESIGN.md and the guidance for the surface; impeccable detect scans a file for anti-patterns such as cramped padding, low contrast, the "thin border and wide shadow" card and overused fonts. The launcher downloads a self-contained binary on first run and checks it against a published SHA-256 checksum before running it.

Install it

The author's installer detects your agents and asks whether to install for the project or globally:

npx impeccable install

Then run /impeccable init in your agent to record the product context. It works with Claude Code, Cursor, Codex, Gemini CLI and others, and on Claude Code it also installs an optional hook that runs the detector after UI edits. From SkillGild:

skillgild install impeccable --agent claude-code

The test

The brief: a landing page for Ledgerline, a fictional bookkeeping app for freelance designers, as one self-contained HTML file with Google Fonts as the only external resource. It listed the sections and forbade invented testimonials, customer counts, logos and awards. Five runs got the same brief: no skill, Anthropic's frontend-design, Taste Skill, UI UX Pro Max and Impeccable. All used Claude Code 2.1.278 with Claude Opus 5 on 9 October 2026, with the Skill tool switched off so nothing else installed could load. One run each: an example, not a benchmark.

How Impeccable worked

It ran impeccable context, found no PRODUCT.md, and noticed it had no way to ask questions in a headless run. So, as its rules require, it inferred the product from the brief and wrote a PRODUCT.md that marks what is inferred and lists what is unknown:

Undecided / unstated (must not be invented by future work): which banks or import methods are supported, which countries' or states' taxes are covered, whether invoicing or expense receipts exist, team or accountant access, data export, annual billing, card-required-or-not at trial signup, mobile apps, integrations.

It then picked a direction with a seeded "concept roll": it listed candidate worlds grounded in the subject and the engine assigned one, here a Swiss departure board. The run's reasoning: money arriving and leaving is a timetable, the quarterly tax date is the next departure, and a board is something you read rather than keep. That became the page's line, "Your money, on the board. Not in a spreadsheet."

With Impeccable. The board's footer says the clients, amounts and dates are made up for the page.

The same brief with no skill.

After building, it read its craft-floor rules, checked contrast and overflow, ran the detector, fixed four real findings, and ran a review pass that caught the hero headline overflowing its column at 1440 px. Finally it wrote a DESIGN.md of about 17 KB describing the system it had shipped, so later work can follow it.

What came out

The client tags flip into place like split-flap letters on load, and a quarter selector (Q2, Q3, Q4) re-flips the whole board. The type is Barlow Condensed for the board and headlines with Barlow for reading text. It is the only one of the five pages you would remember tomorrow.

The whole Impeccable page, top to bottom (no sound). Watch it on skillgild.dev.

Most important, it invented nothing. Every other run, including the one with no skill, added product facts the brief never gave: read-only bank connections, lists of supported countries, CSV and PDF exports, "no card needed", 30-day data retention. Impeccable's page talks only about importing, tagging, tax estimates, the 14-day trial and the $12 plan, which is all the brief said.

We ran Impeccable's detector over all five finished pages:

Detector findings	No skill	frontend-design	Taste Skill	UI UX Pro Max	Impeccable
All findings	21	5	6	27	55
Without `cramped-padding` and design-system rules	17	0	3	21	8

Read the first row with care. Impeccable's run found that most cramped-padding hits are false positives on pages that compute padding with calc(), which its page does throughout. The design-system rules check a page against its own DESIGN.md, so they only fire on Impeccable's page, the only one with a DESIGN.md. With those set aside, its remaining findings are mostly all-caps body text, which is the departure-board style rather than an oversight.

What it costs

The run took 46 turns and 23.8 minutes, and Claude Code reported an API-equivalent cost of $7.49. The baseline took 2 turns, 3.3 minutes and $0.98; the other skills cost between $1.61 and $2.42. Impeccable's own SKILL.md tells the agent to verify in bounded passes rather than loop, and this run did stop, but a full build through every stage is expensive. For small changes, call one command (/impeccable polish, /impeccable audit) instead of asking for a whole new surface.

The departure-board concept also carries risk for a money product: long transaction names in condensed capitals are slower to read, and the split-flap client tags, one letter per tile, take a moment to parse. Because the concept roll is seeded, another run would likely choose a different world; if you want a particular direction, say so, since the brief overrides the roll.

Impeccable at 375 px: no horizontal scroll.

Getting the most from it

/impeccable init
<answer its questions about the product, or point it at your docs>

Use Impeccable to build the landing page. Direction: <a world, or "roll one">.
Keep: <brand constraints>. Then run /impeccable audit and fix what it finds.

Running init interactively gives it real product facts instead of inferences, and the PRODUCT.md it writes keeps every later command honest. For an existing interface, critique and audit are the cheapest way to use it.

Compare it with the other nine in the top Claude frontend and design skills.

Originally published at skillgild.dev.

UI UX Pro Max skill: a design database for Claude Code, tested

SkillGild — Thu, 08 Oct 2026 19:47:48 +0000

UI UX Pro Max is the design skill that brings data instead of opinions. Where Anthropic's frontend-design skill and Taste Skill are written rules, UI UX Pro Max ships a searchable library of styles, palettes, font pairings and UX guidelines, plus a Python script your agent queries before it designs. Its repository by nextlevelbuilder had about 134,000 stars on 9 October 2026, which makes it one of the most-starred design skills for coding agents.

We ran it on a real brief and compared the page with one built from the same brief and no skill. Here is what it contains, how to install it, what its search returned, and what came out.

What is inside

The skill folder holds a SKILL.md of about 200 lines, a data/ folder of CSV files and a scripts/search.py that searches them. Counted on 9 October 2026, the CSVs held:

Data	Rows
Colour palettes, each tied to a product type	192
Industry reasoning rules	192
UX guidelines with rationale	119
Curated icons	105
UI styles (the skill says 79 are searchable, 50 active)	88
Font pairings	74
Landing page patterns	34
Chart types	25
GSAP motion presets	17

The search script uses only Python's standard library, and the README states it makes no network calls.

The SKILL.md tells the agent how to use all this. For a new page, run search.py with --design-system to get a whole direction at once: a page pattern, a style, a palette, a type pairing and effects. For a narrower question, search one domain (--domain ux, typography, color, landing, icons) or a technology stack (--stack). It ranks ten rule categories by priority, from accessibility and touch targets down to charts, and it is explicit that search results are recommendations that never override the user.

Install it

As a Claude Code plugin:

/plugin marketplace add nextlevelbuilder/ui-ux-pro-max-skill
/plugin install ui-ux-pro-max@ui-ux-pro-max-skill

With the author's CLI, which also targets Cursor, Codex, Copilot and others:

npm install -g ui-ux-pro-max-cli
uipro init --ai claude

Or from SkillGild:

skillgild install ui-ux-pro-max --agent claude-code

You need Python 3 for the search script.

The test

The brief: a landing page for Ledgerline, a fictional bookkeeping app for freelance designers, written as one self-contained HTML file with Google Fonts as the only external resource. It listed the sections and forbade invented testimonials, customer counts, logos and awards. One run followed UI UX Pro Max; one had no skill. Both used Claude Code 2.1.278 with Claude Opus 5 on 9 October 2026, with the Skill tool switched off so nothing else installed could load. One run each, so this is an example rather than a benchmark.

What the search returned

The agent's first move was the design-system search. We reran its exact command afterwards; the search is deterministic, so this is the output it worked from:

The design system UI UX Pro Max recommended for the brief. The output continues with typography (Plus Jakarta Sans) and effects.

It then made four narrower searches: accordion keyboard behaviour, single-plan pricing pages, icons for transactions and receipts, and preventing horizontal scroll. The recommendation is sensible for a finance product, and also very familiar: a "trust blue" #2563EB, a light slate ground, one sans-serif and frosted glass. It is close to the "SaaS card kit" that Anthropic's own skill lists as a generated-design tell. A database of what works for a product type tends to return what most products of that type already look like.

The page

With UI UX Pro Max. A floating "41 transactions tagged" card covers part of a transaction row.

The same brief with no skill.

The agent applied the glass style with restraint (frosted header, hero card and pricing card, flat elsewhere) and kept the dark mode off, as the search advised for this product. It noticed that the recommended orange accent reached only about 3.3:1 contrast on the page background and darkened it to #9A3412 wherever orange carried text. It added a skip link, 44 px touch targets, an FAQ built on real buttons, and a sticky trial bar on mobile that appears once the hero form scrolls away.

It was also the longest page in the test, at about 850 visible words, and it kept most of the template chrome the other skills avoided:

Tell	No skill	UI UX Pro Max
All-caps labels	9	9
`A · B` middle-dot strings	4	5
Spaced em dashes	10	10
One phrase accented in the headline	Yes	Yes
Horizontal scroll at 375 px	16 px overflow	None

That is not a failure of the skill so much as a difference in what it is for. UI UX Pro Max is checking accessibility, touch and layout rules, and on those it did well: no overflow at 375 px, contrast fixed, keyboard-friendly components. It does not try to make a page look less like other pages.

The whole UI UX Pro Max page, top to bottom (no sound). Watch it on skillgild.dev.

What went wrong

An overlapping card. In the hero, the floating "41 transactions tagged" confirmation sits on top of the fourth transaction row and hides its client name at 1440 px. Our brief told every run not to open a browser, so none of them could look at its own page; one screenshot of the hero would have caught this. If your setup allows it, ask the agent to check the page visually.

Invented product facts. Like every run in the test except Impeccable's, this one added claims the brief never made: "No card needed to start", a "read-only banking provider" covering "most retail and business banks in the US, UK and EU", CSV and PDF exports, read-only links for your accountant, and data kept for 30 days after the trial. UI UX Pro Max made the most of these, partly because it wrote the most copy.

The run took 17 turns and 8.3 minutes, with an API-equivalent cost of $2.42 reported by Claude Code, against 2 turns, 3.3 minutes and $0.98 for the baseline.

UI UX Pro Max at 375 px: the email field and trial button stack under the headline.

When to use it

Pick UI UX Pro Max when you want a defensible starting system fast, or a second opinion on a specific UX question: the domain searches are quick and specific ("focus not obscured", "badge chip label wraps"). Expect a conventional result unless you push against it. Two habits help:

Use UI UX Pro Max. Run the design-system search, then show me the
recommendation before building. Product facts, and nothing else: <facts>.
Avoid glassmorphism and blue-on-slate; we want <direction>.
After building, screenshot the hero at 1440 px and 375 px and fix overlaps.

For a page that must stand apart, start with frontend-design or Taste Skill and use UI UX Pro Max's UX searches as the checklist. The top Claude frontend and design skills compares all of them.

Originally published at skillgild.dev.

Taste Skill for Claude Code: the anti-slop frontend skill, tested

SkillGild — Thu, 08 Oct 2026 19:38:53 +0000

Taste Skill (install name design-taste-frontend) is the most popular community design skill for coding agents. Its repository by Leonxlnx had about 94,000 stars on 9 October 2026. It calls itself an "anti-slop frontend skill" for landing pages, portfolios and redesigns, and it is the opposite of Anthropic's short frontend-design skill in one respect: where that skill is 71 lines, Taste Skill's SKILL.md runs to about 1,200, most of it explicit rules.

We ran it on a real brief beside a run with no skill. This page explains what the skill does, how to install it, what came out, and the two checks it missed.

What Taste Skill tells your agent

Read the brief and say so. Before any code, the agent must write a one-line "design read": Reading this as: page kind, for audience, with a vibe, leaning toward a design system or aesthetic. If the brief is ambiguous it may ask one question, never several.

Set three dials. Every layout, motion and density decision is gated by three numbers: DESIGN_VARIANCE (1 perfect symmetry, 10 artsy chaos), MOTION_INTENSITY (1 static, 10 cinematic) and VISUAL_DENSITY (1 gallery, 10 cockpit). The baseline is 8 / 6 / 4, and a table maps brief words to values: "minimalist" or "Linear-style" lowers variance and motion; "trust-first" or "regulated" lowers them further.

Avoid a long list of AI tells. Section 9 bans or rations the patterns that mark a generated page. The em dash is banned everywhere, outright. So are three identical feature cards in a row, Inter as the default face, section-number eyebrows like 06 · how it works, "BETA" labels in the hero, decorative status dots, filler verbs ("elevate", "seamless", "unleash") and fake-perfect numbers like 99.99%. The middle dot is rationed to one per line.

Pass a pre-flight check. About 40 tick boxes before the agent hands over: zero em dashes, one accent colour, one radius system, CTA contrast, a hero that fits the viewport with the headline in two lines or fewer, no duplicate CTAs, a copy self-audit. Appendices list install commands for real design systems (shadcn/ui, Radix, GOV.UK Frontend, USWDS, Primer and more) for briefs that should use one.

Install it

From the author's repository with the skills CLI:

npx skills add https://github.com/Leonxlnx/taste-skill --skill "design-taste-frontend"

From SkillGild, for Claude Code, Codex, Cursor or Gemini CLI:

skillgild install design-taste-frontend --agent claude-code

The repository's default design-taste-frontend is v2, which its README calls experimental; design-taste-frontend-v1 installs the original. SkillGild also lists the upstream folder as taste-skill.

The test

The brief: a landing page for Ledgerline, a fictional bookkeeping app for freelance designers, written as one self-contained HTML file with Google Fonts as the only external resource. It listed the sections and forbade invented testimonials, customer counts, logos and awards. One run followed Taste Skill; one had no skill. Both used Claude Code 2.1.278 with Claude Opus 5 on 9 October 2026, with the Skill tool switched off so nothing else installed could load. One run each: an example, not a benchmark.

Taste Skill's run opened exactly as the skill asks:

Reading this as: SaaS landing for solo freelance designers (visually literate, spreadsheet-averse), with a calm, type-led, honest-tool language, leaning toward native CSS + Google Fonts (Outfit + IBM Plex Mono) and a near-monochrome palette with one ink-blue accent.

It set the dials to 7 / 5 / 4, lowering variance from the baseline 8 "because this is a money app and trust matters". It also resolved two conflicts in writing: the skill wants an icon library, but the brief allowed only Google Fonts, so it used no icons; and rather than a fake screenshot (which the skill bans) it built a small working version of the product in the hero, with a client menu on each sample transaction and totals that recompute.

With Taste Skill. The panel is labelled "Example transactions" and the tax figure "an example 25% rate".

The same brief with no skill.

What it got right

The tell counts at 1440 px:

Tell	No skill	Taste Skill
All-caps labels	9	0
`A · B` middle-dot strings	4	0
Spaced em dashes	10	0
Typefaces	Inter + Fraunces	Outfit + IBM Plex Mono
Horizontal scroll at 375 px	16 px overflow	None

Zero em dashes is notable: of the five pages in our test, only Taste Skill's and Impeccable's had none, and Taste Skill's rule is absolute. It was also the shortest page, about 460 visible words against 710 for the baseline, and it labels its sample data as examples in the interface itself.

The whole Taste Skill page, top to bottom (no sound). Watch it on skillgild.dev.

What it missed

Two of its own pre-flight items failed. The headline wrapped to three lines, and at 1440 by 900 the hero copy sits low with a large empty area above it, because it is centred against the taller transaction panel. The pre-flight check asks for a headline of two lines or fewer and says hero content must not "float halfway down the viewport". A long checklist is still checked by the same model that wrote the page, so look at the result yourself at the sizes you care about.

It also accented one word in the headline ("spreadsheet" in blue), which Taste Skill allows and Anthropic's skill discourages. And like every run in the test except Impeccable's, it invented product facts: a read-only bank link, receipt capture, CSV and PDF exports, email support "from the people who build" it, and 30 days to export your data after cancelling. None of that was in the brief.

The run took 13 turns and 7.1 minutes, with an API-equivalent cost of $2.28 reported by Claude Code. The baseline took 2 turns, 3.3 minutes and $0.98.

Taste Skill at 375 px: no horizontal scroll, and a menu button replaces the nav links.

Getting more from it

Taste Skill reacts to vibe words, references and audience, so give it those:

Use Taste Skill (design-taste-frontend) for this landing page.
Product facts, and nothing else: <what it does, price, trial>.
Audience: <who>. Feel: <two or three vibe words>. References: <URLs you like>.
Dials: variance <n>, motion <n>, density <n>.
State your design read and dials before writing code.

Setting the dials yourself is the fastest way to steer it: a lower DESIGN_VARIANCE for a sober product, a higher MOTION_INTENSITY for a launch page. For dashboards and multi-step product UI, the skill itself says it is out of scope; use Impeccable's Operate mode or UI UX Pro Max there.

See all ten in the top Claude frontend and design skills, with four of them run on the same brief.

Originally published at skillgild.dev.

Claude's frontend-design skill: what it does, with a real run

SkillGild — Thu, 08 Oct 2026 19:38:43 +0000

The frontend-design skill is Anthropic's own guidance for making Claude design interfaces that don't look generated. It ships in Anthropic's skills repository and as the frontend-design plugin in the official Claude Code plugin marketplace, and it is the skill most people mean when they search for "the Claude frontend design skill". It is one Markdown file, 71 lines long when we read it on 9 October 2026. It contains no scripts and no component library; everything it changes, it changes by changing how Claude plans.

We ran it on a real brief and compared the result with the same brief and no skill. This page covers what the skill tells Claude, how to install it, what the run produced, and where it falls short.

What the skill tells Claude

Read the SKILL.md and you will find four ideas.

Design from the subject, not from habit. Claude is told to work out the product, the audience and the page's one job first, and to take its visual choices from the subject's own world: its materials, vocabulary and industry.

A named list of generated-design tells. This is the skill's most useful part. It lists the looks AI-generated pages currently cluster around, and asks Claude not to spend a free choice on them:

a warm cream background with a high-contrast serif and a terracotta accent (Anthropic notes that its own Claude accent colour reads as a tell on a user's brief);
a near-black page with one acid-green or vermilion accent;
a broadsheet layout with hairline rules and dense columns;
the "SaaS card kit": identical rounded cards, one radius everywhere, the same soft grey shadow and decorative gradient washes;
template chrome: an ALL-CAPS eyebrow over every heading, A · B · C meta strings, labels built with a spaced em dash, near-black instead of black, monospace data labels and an arrow on every button.

It also bans three typographic habits outright: accenting a single word in the headline, all-caps labels, and labels nobody needs. Numbered markers (01, 02, 03) are allowed only when the content really is a sequence.

Plan, check the plan, then build. Before any code, Claude writes a compact token system: 4 to 6 named hex colours, the typefaces and their roles, a layout sketched in ASCII, and the page's principles. It then reviews the plan against the brief, and revises any part that looks like the default it would produce for any similar page.

Restraint and plain copy. "Spend your boldness in one place", keep a quality floor (responsive, visible focus, reduced motion respected), and write copy that says what things do in the user's words.

Install it

In Claude Code, from the official marketplace:

/plugin install frontend-design@claude-plugins-official

From SkillGild, which installs the same skill for Claude Code, Codex, Cursor or Gemini CLI:

skillgild install frontend-design --agent claude-code

Or copy the folder by hand: clone anthropics/skills and place skills/frontend-design in ~/.claude/skills/. The install guide lists the folders for other agents. The skill triggers on its own when you ask for UI work; you can also name it in your prompt.

The test: one brief, with and without the skill

We gave Claude Code the same brief twice: a landing page for Ledgerline, a fictional bookkeeping app for freelance designers, as one self-contained HTML file with Google Fonts as the only external resource. The brief listed the sections and forbade invented testimonials, customer counts, logos and awards. One run had the frontend-design skill in its project folder and was told to follow it; the other had no skill. Both used Claude Code 2.1.278 with Claude Opus 5 on 9 October 2026, with the Skill tool switched off so no other installed skill could load. Each ran once, so treat this as one example, not a benchmark.

With the frontend-design skill. The hero is a working tagging demo: pick a client swatch, click a transaction, and the totals update.

The same brief with no skill. A competent page, built on the cream-and-serif look the skill lists as a tell.

What the skill changed

Before writing code, the skill run produced exactly the plan the SKILL.md asks for: a five-colour palette named for the subject ("drafting-paper sage", "navy ink"), with four client colours that mean "client" everywhere on the page rather than decorating it; Familjen Grotesk for text and IBM Plex Mono only for amounts and dates; an ASCII wireframe of the hero. Then it built the hero as a small working tool: choose a client, click transactions in a sample month, and the per-client totals and the quarterly tax set-aside recompute.

The baseline is not bad. Claude Opus 5 without help produced a tidy page with a product card, an accessible FAQ accordion and reduced-motion support. But it landed squarely on the defaults the skill names: a cream background with a serif display face, a highlighted phrase in the headline, an all-caps pill over the hero and all-caps section labels.

We counted those tells on both pages at 1440 px:

Tell the skill names	No skill	frontend-design
All-caps labels	9	0
`A · B` middle-dot strings	4	0
Spaced em dashes in the copy	10	7
One word or phrase accented in the headline	Yes	No
Numbered markers	0	3, on the three real steps
Horizontal scroll at 375 px	16 px overflow	None

The whole frontend-design page, top to bottom (no sound). Watch it on skillgild.dev.

The skill run also cost more. It took 14 turns and 5.7 minutes against 2 turns and 3.3 minutes for the baseline, and Claude Code reported an API-equivalent cost of $1.61 against $0.98. Most of the extra went on the plan and a self-critique pass that made nine small edits.

What it did not fix

Both pages invented product facts the brief never gave. The skill run says Ledgerline connects to "most banks and credit unions in the US, Canada, the UK and the EU", keeps data exportable for 30 days, needs no card to start and matches receipts. The baseline made similar claims. frontend-design shapes how a page looks and reads; it does not know what your product does. Of the four skills we tested, only Impeccable refused to invent facts, because it records what the brief leaves unstated. With this skill, put the real facts in the brief and tell Claude not to add features.

It also kept seven spaced em dashes, so the tell list is a strong nudge rather than a filter. If a look matters to you, say so in the brief: the skill's own rule is that the brief's words always win.

The skill run at 375 px. No horizontal scroll; the demo stacks under the headline.

Briefs that get the most from it

The skill works from your brief, so give it the material it asks for:

Use the frontend-design skill to build the landing page for <product>.
Product facts (do not add others): <what it does, price, trial, integrations>.
Audience: <who>, and the one action the page should drive: <action>.
Keep: <brand colours, fonts, routes>. Avoid: <looks you dislike>.
Show me the token plan and ASCII layout before you write code.

Asking to see the plan first is cheap and gives you a decision point before the build. If the plan's palette or type is wrong for your brand, correct it there.

When to pick something else

frontend-design is a direction skill: it decides how a new page should look. For an audit of an existing interface, pair it with Web Design Guidelines or Impeccable's audit commands. For motion, add Emil Kowalski's skills. If you want options to choose between rather than one opinion, UI UX Pro Max searches a database of styles and palettes instead. The top 10 Claude frontend and design skills compares all of them, with the same brief run through four.

Originally published at skillgild.dev.

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.