# 20 Best Claude Code Skills for Solo SaaS Founders in 2026 (Ranked & Tested)

> 20 real Claude Code skills ranked and tested with a concrete task per skill, token cost tier, and a skills-vs-subagents-vs-hooks primer — for solo SaaS founders.

Canonical: https://www.agentickit.co/blog/best-claude-code-skills-2026
Last updated: 2026-10-29

**Short answer:** the best Claude Code skills for a solo SaaS founder are the ones that fire on a real failure mode (a missing Stripe signature check, an N+1 query, a thin meta description) and load fast enough that you don't think about the token cost. Below are 20 ranked skills from AgenticKit's own `.claude/skills/` catalog, tested the same way you'd actually use them — one real task per skill, timed from install to first correct run — plus a category breakdown and the native-vs-generic primer most "best skills" roundups skip.

If you haven't used a Claude Code skill yet, read the primer section first. If you already know what a `SKILL.md` is and just want the ranked list, jump to [Top 20 ranked](#top-20-claude-code-skills-ranked).

## What are the best Claude skills right now?

"Claude skills" and "Claude Code skills" are the same thing — a `SKILL.md` playbook that Claude Code (or Claude.ai, which supports the same file format for its own skills feature) loads only when the task matches the skill's description. For a solo SaaS founder, the best Claude skills are `security-basics`, `stripe-billing-webhooks`, `auth-patterns`, `api-patterns`, and `on-page-seo` — see the full ranked 20 below for why each one earns a slot and what it actually caught when tested.

## Slash commands vs. skills: the distinction people actually search for

Most confusion isn't skill-vs-subagent, it's skill-vs-slash-command — both live in `.claude/` as markdown, and both can carry frontmatter, so from the file listing alone they look the same. The difference is who decides to run them:

| | Slash command | Skill |
|---|---|---|
| File location | `.claude/commands/<name>.md` | `.claude/skills/<name>/SKILL.md` |
| How it's invoked | You type `/name` explicitly | Claude Code matches your request against the `description` and loads it automatically |
| What it's for | A saved, repeatable workflow you choose to run (`/ship`, `/seo-audit`) | A standing playbook the agent should follow whenever the task fits, without you remembering to ask |
| Typical content | A multi-step pipeline prompt, sometimes chaining agents and skills | A narrower pattern or checklist (a security check, a billing-webhook convention) |
| Risk if you forget it exists | You just don't run it that session | None — it fires on its own if the description matches, which is the whole point |

If you catch yourself writing a command you always mean to run on every matching task anyway, that's usually a sign it should be a skill instead — see [the full commands catalog](/commands) for the 47 saved workflows AgenticKit ships, and the ranked skills above for the playbooks that load themselves.

## How a Claude Code skill differs from a subagent or a hook

Claude Code ships three separate ways to extend what the agent does automatically, and people conflate them constantly — enough that generic listicles rarely explain the difference before diving into a directory dump:

- **Skill** (`.claude/skills/<name>/SKILL.md`) — a markdown playbook with `name` and `description` frontmatter. Claude Code reads every skill's description up front, then loads the full file into context only when the current task matches it. You don't invoke a skill directly; the agent decides, based on whether your request matches the description.
- **Subagent** (`.claude/agents/<name>.md`) — a separate agent definition with its own system prompt and tool access, spun up via the `Agent` tool (or `/agents`) to do a bounded unit of work — code review, a research pass — and report back, keeping its own tool noise out of your main context.
- **Hook** — a shell command Claude Code's settings.json runs automatically on a lifecycle event (before a tool call, after a file edit, on session stop), independent of any prompt. It can block an action outright; no model judgment involved.

The practical difference that matters for ranking: a skill only earns its keep if its description is specific enough to trigger on the right task and short enough that loading it doesn't burn context you needed for the actual work. That's the axis the "token cost" column below is testing.

## Testing method: install time, token cost, task tested on

Every skill below is a real file in [AgenticKit's 61-skill catalog](/skills), installed the same way: `npx agentickit-cursor init --target claude`, which drops the whole set into `.claude/skills/`. For each one we recorded:

1. **Install time** — all 61 land in one command, so this is identical across the catalog: under a minute, no per-skill setup. The real variable isn't install time, it's whether a skill's `description` is specific enough that Claude Code actually picks it up on the matching task without you naming it manually.
2. **Token cost tier** — Low / Medium / High, based on how long the skill's body actually is once loaded (a 4-bullet pattern skill vs. an 8-step checklist with examples). Short, glob-tight skills cost less context per trigger; long checklist skills cost more but replace a much longer manual review.
3. **Task tested on** — the concrete prompt we ran against a fresh Next.js + Supabase + Stripe repo to confirm the skill actually fired and the agent followed it, not just that the file exists.

Skills that only pay off with a team (multi-reviewer workflows, large-org compliance checklists) are excluded — the [full catalog](/skills) has 40+ more if you need them later.

## Top 20 Claude Code skills, ranked

| # | Skill | Category | Token cost | Task tested on |
|---|---|---|---|---|
| 1 | [security-basics](/skills/security-basics) | Shipping | Medium | "Review this repo for exposed API keys and missing auth checks before I deploy" |
| 2 | [stripe-billing-webhooks](/skills/stripe-billing-webhooks) | Deploy | High | "Add a Stripe webhook handler for subscription updates" — caught a raw-body parsing bug on first try |
| 3 | [auth-patterns](/skills/auth-patterns) | Shipping | Medium | "Add a protected dashboard route that only the account owner can see" |
| 4 | [api-patterns](/skills/api-patterns) | Shipping | Low | "Build a POST /api/invites route" — enforced Zod validation and the standard error envelope without being asked |
| 5 | [postgres-drizzle](/skills/postgres-drizzle) | Shipping | Medium | "Add a `projects` table with a foreign key to `teams`" — added the index that would've been missed |
| 6 | [next-app-router](/skills/next-app-router) | Shipping | Low | "Build a settings page with a form" — kept the mutation in a Server Action, not a client fetch |
| 7 | [error-handling](/skills/error-handling) | QA | Low | "Wrap this external API call so a timeout doesn't crash the request" |
| 8 | [playwright-e2e](/skills/playwright-e2e) | QA | High | "Write an E2E test for sign-up through checkout" — see the full [Playwright SKILL.md walkthrough](/blog/cursor-playwright-skill) |
| 9 | [testing-vitest](/skills/testing-vitest) | QA | Low | "Write unit tests for this pricing calculation function" |
| 10 | [typescript-strict](/skills/typescript-strict) | Shipping | Low | "Fix the type errors in this file" — refused to `any`-cast its way out, which is the actual point |
| 11 | [exploratory-qa](/skills/exploratory-qa) | QA | Medium | "Click through the signup flow like a new user and list anything broken" |
| 12 | [performance-web](/skills/performance-web) | Shipping | Medium | "This page feels slow, check Core Web Vitals issues" |
| 13 | [on-page-seo](/skills/on-page-seo) | SEO/Growth | Medium | "Review this blog post draft for on-page SEO before I publish" — see the [/seo-audit command](/commands/seo-audit) |
| 14 | [entity-seo](/skills/entity-seo) | SEO/Growth | Low | "Add JSON-LD schema to this page" |
| 15 | [pillar-cluster](/skills/pillar-cluster) | SEO/Growth | Medium | "Plan a content cluster around 'Claude Code hooks'" |
| 16 | [landing-page-cro](/skills/landing-page-cro) | SEO/Growth | Medium | "Review this pricing page for conversion issues" |
| 17 | [github-actions](/skills/github-actions) | Deploy | Medium | "Add a CI workflow that runs tests and type-checks on every PR" |
| 18 | [docker-deploy](/skills/docker-deploy) | Deploy | Medium | "Write a multi-stage Dockerfile for this Next.js app" |
| 19 | [sre-observability](/skills/sre-observability) | Deploy | Medium | "Add structured logging and an error alert for failed webhook deliveries" |
| 20 | [dependency-upgrades](/skills/dependency-upgrades) | Deploy | Low | "Upgrade Next.js to the latest major version safely" |

## Category breakdown: where the catalog actually clusters

**Shipping (7 of the 20):** `security-basics`, `auth-patterns`, `api-patterns`, `postgres-drizzle`, `next-app-router`, `typescript-strict`, `performance-web`. These are the skills you want loaded before Claude Code touches anything that reaches a real user — auth, data, and the default App Router shape. If you only install one category, install this one.

**QA (4 of the 20):** `error-handling`, `playwright-e2e`, `testing-vitest`, `exploratory-qa`. Notably the cheapest to run relative to the time they save — `error-handling` is a Low-cost skill that prevents a specific class of unhandled-rejection crash every time it fires.

**Deploy (5 of the 20):** `stripe-billing-webhooks`, `github-actions`, `docker-deploy`, `sre-observability`, `dependency-upgrades`. The highest average token cost in the list, because deploy mistakes are the most expensive to get wrong silently — a bad webhook handler or a missed CI check doesn't fail loudly, it fails three weeks later as a support ticket.

**SEO/Growth (4 of the 20):** `on-page-seo`, `entity-seo`, `pillar-cluster`, `landing-page-cro`. Lower average cost, and the only category where you'll want to run the skill manually before every publish rather than trust the description match alone — SEO tasks are phrased too many different ways for a trigger description to catch all of them reliably.

## What you'd still write yourself

None of the 20 above replace your own repo's conventions. A skill ships the generic pattern (webhook idempotency, Suspense boundaries, a Zod-validated error envelope); it doesn't know your table names, your route structure, or your specific onboarding flow. Pair any of these with a short [project-conventions](/skills/project-conventions) skill written for your own repo, and keep its description specific — a skill only fires when the description actually matches what you asked for, so a vague one sits unused no matter how good the body is.

The always-on counterpart to these skills is CLAUDE.md itself — see [15 Real CLAUDE.md Files From Production SaaS Repos](/blog/claude-md-examples-production-saas) for annotated examples of what belongs in CLAUDE.md versus what's better off as a skill like the ones above.

## Where to get these skills fast

```bash
npx agentickit-cursor init --target claude
```

This installs all 61 skills (31 engineering, 30 marketing/growth) into `.claude/skills/`, alongside AgenticKit's 34 subagents and 47 commands, in one shot — no per-skill copy-paste. Browse the [full skills catalog](/skills) if you want to see all 61 before installing, or start from the [commands directory](/commands) if you'd rather trigger things manually than wait for a description match.

## FAQ

**What's the difference between "Claude skills" and "Claude Code skills"?** None in format — both terms point at the same `SKILL.md` file (YAML frontmatter plus markdown instructions). "Claude skills" is the shorter, more common way people search for this; "Claude Code skills" specifies the Claude Code CLI/IDE product where this list's 20 picks were tested, as opposed to Claude.ai's own skills surface.

**How is this different from a generic "best Claude Code skills" roundup?** Most roundups list skill names from a GitHub directory without running them. Every skill here is tested against one concrete prompt on a real repo, with a token-cost tier based on the skill's actual loaded length, not a popularity guess.

**Do I need to pick a specific 20, or just install everything?** Install everything — `npx agentickit-cursor init --target claude` takes the same amount of time whether you use 5 skills or 61. The ranking here is for *attention*, not install order: it tells you which 20 are worth reading the `SKILL.md` for first.

**Skill vs. subagent vs. hook — which do I need for a specific task?** See [Skills differ from subagents and hooks](#how-a-claude-code-skill-differs-from-a-subagent-or-a-hook) above. Short version: skill for a playbook the agent should load automatically, subagent for a bounded task you want run and reported back separately, hook for something that must happen on every matching event with zero chance of being skipped.

**Why does token cost matter if context windows are large?** A large context window doesn't mean loading everything is free — every skill that fires competes with your actual task for the agent's attention inside that window. A Low-cost skill that fires constantly (like `api-patterns`) is a better trade than a High-cost skill that fires rarely; that's why `stripe-billing-webhooks` is ranked by how often it matters, not by how cheap it is to load.

**I only have time for five. Which five?** `security-basics`, `stripe-billing-webhooks`, `auth-patterns`, `api-patterns`, and `on-page-seo` — the four most expensive failure modes for a solo founder plus the one SEO check worth running before every publish.

**Do these skills also work in Cursor?** Yes — `SKILL.md` is an open format, and AgenticKit ships the identical files to both `.claude/skills/` and `.cursor/skills/`. If Cursor is your primary editor, the Cursor-specific ranked version of this list is [25 Best Cursor Skills for Solo SaaS Founders in 2026](/blog/25-best-cursor-skills-2026-ranked).

**Are skills as risky to install as plugins?** No — a skill is inert markdown the agent only follows when its description matches your task, unlike a Claude Code plugin, which can register a hook script that runs unconditionally on every tool call. See [the plugin marketplace governance guide](/blog/claude-code-plugin-marketplace-governance-2026) for why that distinction matters and the audit checklist to run before installing a plugin.

## Next steps

Install the set, then read the primitives breakdown if skills, subagents, and hooks still feel blurry: [Cursor Rules vs Skills vs Commands vs Hooks](/blog/rules-vs-skills-vs-commands-vs-hooks) covers the Cursor-side naming, and the section above covers the Claude Code side. This list stops at engineering/QA/deploy — if you're also running your own marketing, see [Best Claude Code Skills for Solo Founder Marketing & SEO in 2026](/blog/best-claude-code-skills-marketing-seo-2026) for the positioning/SEO/growth category. Full install and the rest of the kit: [pricing](/pricing).


## Related
- [rules-grader](https://www.agentickit.co/tools/rules-grader)
- [config-converter](https://www.agentickit.co/tools/config-converter)
- [code-reviewer](https://www.agentickit.co/agents/code-reviewer)
- [security-auditor](https://www.agentickit.co/agents/security-auditor)
- [seo-specialist](https://www.agentickit.co/agents/seo-specialist)
- [security-basics](https://www.agentickit.co/skills/security-basics)
- [stripe-billing-webhooks](https://www.agentickit.co/skills/stripe-billing-webhooks)
- [on-page-seo](https://www.agentickit.co/skills/on-page-seo)
- [/seo-audit](https://www.agentickit.co/commands/seo-audit)
- [/audit](https://www.agentickit.co/commands/audit)
