Skills library

Anthropic’s reference public skills repository: reference skills, the Agent Skills spec and a skill template, installable as sets from its marketplace.

The four production document skills that power Claude's file creation: read/create/edit Word, PDF, PowerPoint and Excel files with proper formatting, tracked changes, formulas and charts.

Anthropic's official skill for writing skills: scaffolds a SKILL.md with correct frontmatter, structure and intention-revealing supporting files; the recommended starting point before authoring anything by hand.

Guides Claude through designing and generating a working MCP server, the official first-party recipe for wrapping an API as agent tools.

Anthropic's anti-generic UI skill: aesthetic direction, typography and layout guidance for production-grade interfaces that do not look templated; exists both in anthropics/skills and as a plugin in the official directory.

First-party skill for driving and testing a running web app in a browser, verifying behavior instead of assuming it from code.

Builds elaborate self-contained HTML artifacts (multi-component single-file pages) reliably, the official recipe behind rich claude.ai artifacts.

Loads current Claude API reference (model IDs, tool use, streaming, batches, structured outputs) per language, auto-activates when code imports the anthropic SDK, and /claude-api migrate upgrades code to newer models.

Chart and dashboard design guidance loaded into context: chart-type choice, colour by role, layout rules, plus a palette validator for colour blindness and contrast.

Bundled multi-agent diff review at chosen effort level (low to max, plus cloud 'ultra'), with --fix and --comment; /simplify runs the cleanup-only sibling that applies reuse/simplification fixes without bug hunting.

Orchestrates a large-scale change across a codebase: presents a plan, then after your approval runs one subagent per unit of work in an isolated git worktree, which runs the tests and publishes the change.

Trio that launches the actual app and observes behavior instead of trusting tests; run-skill-generator records the project's launch recipe as a per-project skill at .claude/skills/run-<name>/ so all agents reuse it.

Fans out web searches on a question, fetches and cross-checks sources, and synthesizes a cited report as a background multi-subagent workflow.

Recurrence primitives: /loop reruns a prompt on an interval (or self-paced autonomous maintenance from .claude/loop.md) while the session is open; /schedule creates cloud routines on Anthropic infrastructure.

Converts your repo's React design system and uploads it to Claude Design so generated designs use your real components; first sync verifies every component.

Session hygiene skills: /debug turns on debug logging and diagnoses issues from the session log; /fewer-permission-prompts mines your transcripts to build a read-only allowlist in settings.json.

The Anthropic-run plugin directory, already present in Claude Code: plugins written by Anthropic (feature-dev, hookify, plugin-dev, language servers…) and vetted partner plugins. Anthropic does not control these plugins’ MCP servers: check them anyway.

An official plugin that writes hooks for you, the automatic rules that block a Claude behaviour the model alone cannot guarantee.

Anthropic’s open-source plugins for non-engineering roles (productivity, sales, support, product, marketing, legal, finance, data): the official starting points for business workflows, shared with Cowork.

The SKILL.md format published as an open standard: the spec lives in anthropics/skills, and a skill written for it also works in other tools (Copilot, VS Code, Cursor, Codex, Gemini CLI…).

The reference framework for agent-driven development: method skills (brainstorming, planning, test first, debugging, review, verification) that make Claude Code work like a seasoned engineer.

Companion repo of experimental, not-yet-graduated Superpowers skills and techniques; worth watching for what lands in the main framework next.

A very large collection of skills, agents, hooks and rules for Claude Code and other tools, with a security check (AgentShield). Its flagship skills: continuous-learning-v2, security-scan, eval-harness, e2e-testing and content-engine.

Andrej Karpathy’s criticisms of LLM-written code, condensed into four behaviour rules: no silent assumptions, no over-engineering, no off-topic changes, explicit verification.

Turns Claude Code into a full game studio: agents organised as director, lead and specialist, workflow skills (from /start to /launch-checklist), hooks and templates, with agents dedicated to Godot, Unity and Unreal.

Web design skills specialised in 3D and animation (Three.js, R3F, GSAP, Babylon.js, PixiJS, Rive, Spline, Lottie), installable one by one. The best set dedicated to 3D and motion on the web.

The most complete SEO skill: sub-skills and agents for technical SEO, E-E-A-T, JSON-LD, AI citability, local, e-commerce and hreflang, with a “how would we know this failed?” check on every recommendation.

Production SEO skills built on the SE Ranking MCP server (content briefs, AI Search share of voice, audits, backlink gaps, keyword clusters, schema, sitemap, GEO); every API call documented so it adapts to other data providers.

SEO + AI-search (GEO/AEO) toolkit with a two-score audit (classic SEO vs LLM citability) and an opt-in fixer, explicitly designed for the 2026-2027 answer-engine landscape.

A blog-writing suite, companion to claude-seo: sub-skills, agents and delivery checks, for Google rankings as well as AI citations.

A marketplace of professional-grade security plugins from Trail of Bits: differential code review, fix verification, Semgrep rules, supply chain, cryptography, reverse engineering and smart contracts.

The main curated awesome list of the ecosystem: indexes official document skills, design/creative skills, superpowers, Trail of Bits and community collections; best starting map for discovery.

A large index of skills, agents and prompt shortcuts, browsable at clskills.in. Useful as a catalogue to search rather than a vetted list.

Skills, agents and commands for engineering but also marketing, product, compliance, leadership, finance and productivity. The best coverage of non-engineering jobs.

A very large toolkit: agents, plugins, curated skills, commands, hooks and MCP configurations. Its flagship workflow plugin handles a self-correcting memory and parallel git worktrees.

A curated collection of skills that follow the agentskills.io open standard, usable in Claude Code as well as Cursor, Copilot, Codex or Gemini CLI.

The largest raw index in the ecosystem: SKILL.md files collected from GitHub, sorted by domain, with a free API and an MCP server. No curation: every skill needs your own check before you install it.

The Vercel-backed cross-platform registry (Claude Code, Cursor, Copilot, Codex), ranked by activity and real installs, with an official section and a security audit shown for each skill.

A mid-size catalogue mixing official and community skills, all free, in SKILL.md format. A good middle ground between a raw crawl and a hand-picked list.

A directory of marketplaces rather than skills, formerly claudemarketplaces.com: it lists every day the GitHub repositories that publish a marketplace. The place to see what exists before adding one.

The versioned skill registry for OpenClaw agents, not for Claude Code. After a malicious-skill campaign it added automated scanning, author verification and signing: safer, not immune.

The Anthropic-run community marketplace: third-party plugins that passed automated validation and a safety screen, with a lower bar than the official directory.

A small hand-picked marketplace that security-checks every listing and pays creators. Small catalogue, high quality floor, and good neutral guides on marketplaces.

A large index of collected skills, with a polished web interface, aimed at the LobeHub agent ecosystem rather than Claude Code. Useful as a second search surface.

A classic list of hand-picked skills sorted by category, maintained by @BehiSecc: the best signal-to-noise ratio if you prefer quality over volume.

A submission-based skill directory attached to MCP Market, highlighting skills that pair with MCP servers (data extraction, databases, cloud APIs).

A browsable directory of Claude Code plugin marketplaces, useful to cross-check crossaitools.com.

A personal marketplace on GitHub, with skills for development workflows. Typical of the single-author repositories you add with /plugin marketplace add.

xiaolai’s personal marketplace. Its quality depends on what its author maintains, as with any single-author marketplace.

A skill directory for several agents (Claude, OpenClaw, GitHub agents): one more discovery surface for the SKILL.md format.

The reference open-source scanner for installed MCP servers and skills: prompt injection, poisoned or shadowed tools, later behaviour changes, malicious payloads, hard-coded secrets.

Paste a skill URL into a browser tool to get Snyk's LLM-judge plus deterministic-rule verdict BEFORE installing anything locally; same engine that scans skills.sh submissions at install time.

The most thorough open-source skill scanner: vulnerability patterns (injection, exfiltration, privilege escalation), YARA signatures, CVE lookups, code analysis and an optional LLM pass. It reads a folder, a git URL or an archive.

Governance layer shipped 2026-05-22: machine-readable YAML/JSON Skill Cards (builder identity, API dependencies, scan results) plus cryptographic signing of the whole skill directory via the OpenSSF Model Signing standard, verifiable with NVIDIA's root certificate; catalog still sparse (cuOpt first).

The scanner from Koi, the team that uncovered ClawHavoc: it checks a skill published on ClawHub, by name, before install, and returns a benign, malicious or unknown verdict. It covers neither Claude Code plugins nor a skill copied from GitHub.

Instruction-layer scanner: analyzes the natural-language SKILL.md directions (intent, permission scope vs need, persistent behavior modification, exfiltration vectors) rather than only code, claiming about 2.4x more threats caught than static analysis alone; complementary to mcp-scan.

A scanner inspired by formal verification, with a component inventory (SBOM) and supply-chain checks, for many agent frameworks including Claude Code skills, MCP, LangChain and CrewAI.

An independent scanner for skills and MCP tools: prompt injection, indicators of compromise and malware. Useful as a second engine next to another scanner.

Deliberately malicious skill corpus from the ToxicSkills study: use it in quarantine to benchmark whether your own vetting pipeline actually catches real payload patterns before trusting it.

Emerging taxonomy of skill-specific risks (AST01 Malicious Skills is critical severity) with per-platform checklists for Claude Code, OpenClaw, Cursor, VS Code and mitigations (ed25519 signing, behavioral scanning, sandboxed execution, audit logging); incubator status, last updated March 2026.

Dynamic detonation auditor from the July 2026 'Cloak and Detonate' paper: runs a suspect skill in an instrumented sandbox and watches runtime behavior, detecting 97% of SkillCloak-obfuscated attacks at 2% false positives where every static scanner tested was largely blind.

Benchmark for skill-vetting pipelines: stage one does semantic vetting of the SKILL.md specification for hidden malicious intent, stage two executes flagged skills in an instrumented sandbox; use it to compare scanner quality claims.

Hierarchical triage framework (research) for detecting malicious AI agent skills at marketplace scale, a cheap-first/expensive-later pipeline design worth copying if you vet many skills.

Moves agent tool execution into user-controlled infrastructure (own infra or Cloudflare, Daytona, Modal, Vercel), announced at Code w/ Claude London May 2026: the isolation layer that makes running unvetted skills survivable.

Cloud Security Alliance governance guide for MCP and agent-skill deployments: policy-level companion to the hands-on scanners for anyone formalizing a vetting process.

Retro-hunting material for the ClawHavoc campaign: 14 malicious file hashes, 5 C2 IPs (incl. 91.92.242.30), domains (socifiapp.com), and the 12 attacker author IDs; sweep any skills installed January-February 2026 against it.

Commercial continuous agent-security orchestration plus an AI bill-of-materials inventory: the enterprise tier above the free agent-scan for teams running many agents and skills.

Create, read, edit, and manipulate Word documents (.docx), including tracked changes, comments, images, find-and-replace, and polished formatted deliverables like reports and letters.

Full PDF toolbox: extract text and tables, merge/split, rotate, watermark, fill forms, encrypt/decrypt, extract images, and OCR scanned PDFs.

Create, read, and edit PowerPoint decks: build presentations from scratch or templates, extract slide text, and work with layouts, speaker notes, and comments.

Open, create, and fix spreadsheets (.xlsx/.xlsm/.csv/.tsv): formulas, formatting, charts, and cleaning messy tabular data, with a zero-formula-error delivery standard.

Create original static visual art and posters as .png or .pdf by first writing a design philosophy, then expressing it on canvas.

Generate algorithmic and generative art with p5.js (flow fields, particle systems) using seeded randomness and an interactive parameter viewer.

Apply one of 10 preset color/font themes (or generate a new one) to any artifact: slides, docs, reports, or landing pages.

Apply Anthropic's official brand colors and typography to artifacts; a template for encoding any company's visual identity as a skill.

Create animated GIFs sized and optimized for Slack (128x128 emoji, 480x480 message) with validation utilities and animation concepts.

Write internal communications in company formats: 3P updates, status reports, leadership updates, newsletters, FAQs, and incident reports.

Structured three-stage workflow (context gathering, refinement, reader testing) for co-authoring docs, proposals, specs, and decision documents.

End-to-end feature development workflow with specialized agents for codebase exploration, architecture design, and quality review.

Automated pull-request review using multiple specialized agents with confidence-based scoring of findings.

PR review agents specializing in comments, tests, error handling, type design, code quality, and simplification.

Simple slash commands for the git workflow: committing, pushing, and creating pull requests.

Agent that refines code for clarity, consistency, and maintainability without changing behavior.

Modernize legacy codebases (COBOL, old Java/C++/.NET, monoliths) via a structured assess/map/extract-rules/transform/harden workflow, including cross-stack rewrites and version uplifts.

Toolkit for developing Claude Code plugins: creating agents, commands, hooks, MCP integrations, and correct plugin structure.

Maintain CLAUDE.md files: audit quality, capture session learnings, and keep project memory current.

Analyze a codebase and recommend tailored Claude Code automations: hooks, skills, MCP servers, and subagents.

Development kit for building applications with the Claude Agent SDK.

Skills for designing MCP servers that work well with Claude: deployment models (remote HTTP, MCPB, local), tool design patterns, auth, and interactive MCP apps.

Connect Claude to a private MCP server through an Anthropic MCP tunnel; drives the Docker Compose quickstart end to end (certificates, proxy, cloudflared).

Security review of code written by Claude: warns on about twenty dangerous patterns during edits, then sends the diff to a model at the end of each turn, which uses quota. Needs Python 3.8 or later.

Runs Claude in a loop on the same prompt until the task is done. Always set --max-iterations (20, say): with no limit the loop can run forever and use up your quota.

Generate an explorable HTML report of Claude Code session usage from local transcripts: tokens, cache efficiency, subagents, skills, and most expensive prompts.

Publish a living project status page (overview, workstreams, next steps) as a shareable claude.ai artifact that refreshes to the same URL and reports only deltas.

Create interactive single-file HTML playgrounds with visual controls and live preview; includes templates for design playgrounds, data explorers, concept maps, and document critique.

Solve competition math (IMO, Putnam, USAMO) with fresh-context adversarial verifiers that attack proofs, plus calibrated abstention instead of bluffing.

Adds educational insights about implementation choices and codebase patterns while working (revives the deprecated Explanatory output style).

Interactive learning mode that pauses and asks you to contribute meaningful code at decision points instead of writing everything itself.

One-command onboarding for the Code-with-Claude Makers Cardputer: clones the build-with-claude repo, flashes UIFlow firmware, and installs the Claude Buddy app on an M5Stack Cardputer-Adv.

Reference plugin demonstrating every Claude Code extension surface: commands, agents, skills, hooks, and MCP servers.

TypeScript/JavaScript language server integration for enhanced code intelligence in Claude Code.

Python language server (Pyright) for type checking and code intelligence in Claude Code.

Rust language server (rust-analyzer) for code intelligence and analysis in Claude Code.

Go language server (gopls) for code intelligence and refactoring in Claude Code.

C/C++ language server (clangd) for code intelligence in Claude Code.

Java language server (Eclipse JDT.LS) for code intelligence in Claude Code.

C# language server for code intelligence in Claude Code.

Kotlin language server for code intelligence in Claude Code.

Swift language server (SourceKit-LSP) for code intelligence in Claude Code.

Ruby language server for code intelligence and analysis in Claude Code.

PHP language server (Intelephense) for code intelligence in Claude Code.

Lua language server for code intelligence in Claude Code.

Socratic design refinement before any creative work: explores user intent, requirements, and design alternatives before implementation starts.

Turns a spec or requirements for a multi-step task into a detailed written implementation plan before touching code.

Executes a written implementation plan in batches with review checkpoints, designed for running the plan in a separate session.

Enforces the RED-GREEN-REFACTOR cycle for any feature or bugfix, with a reference of testing anti-patterns to avoid.

4-phase root-cause process for any bug or test failure before proposing fixes, including root-cause tracing, defense-in-depth, and condition-based-waiting techniques.

Requires running verification commands and confirming their output before claiming work is complete, fixed, or passing: evidence before assertions.

Sets up parallel development branches via git worktrees so multiple lines of work can proceed without stepping on each other.

Pre-review checklist for preparing work before asking for a code review.

Structured way to respond to code-review feedback instead of blindly accepting or ignoring it.

Executes implementation plans with independent tasks in the current session using fast iteration and two-stage review (spec compliance, then code quality).

Runs concurrent subagent workflows to parallelize independent chunks of work.

When implementation is done and tests pass, guides the merge-vs-PR-vs-cleanup decision with structured options.

Meta-skill for creating new Claude Code skills following best practices, including a methodology for testing the skill itself.

Entry-point skill that establishes how to find and invoke the other skills at the start of any conversation, before any response.

Research-before-coding workflow: search existing code, docs, and prior art before writing anything new.

Test-driven development methodology adapted to Claude Code sessions.

Continuous verification process so changes are checked as they land rather than at the end.

Builds evaluation harnesses to back the verification loop with measurable pass/fail gates.

Watches your sessions through hooks before and after each tool, turns them into confidence-scored “instincts” and stores them per project. It saves excerpts of your sessions to disk.

Cross-language coding best practices applied during generation and review.

Go idioms and best practices; paired with golang-testing for Go test patterns, TDD, and benchmarks.

Python idioms and best practices for writing production Python.

Python testing patterns with pytest.

C++ standards based on the C++ Core Guidelines; cpp-testing covers GoogleTest and CMake/CTest patterns.

Server-side architecture patterns: APIs, databases, and caching for Node.js/Express/Next.js backends.

React and Next.js frontend patterns for component structure and data flow.

REST API design: resource naming, status codes, pagination, filtering, error responses, versioning, rate limiting.

Playwright end-to-end testing patterns including the Page Object Model.

PostgreSQL optimization patterns for schema and query work.

ClickHouse analytics and data-engineering patterns.

Safe migration patterns across Prisma, Drizzle, Django, and Go migration tooling.

CI/CD, Docker, health checks, and rollback patterns for shipping to production.

Docker Compose, networking, volumes, and container security patterns.

Django models/views/architecture patterns; companion skills cover django-security, django-tdd, and django-verification.

Laravel architecture patterns; companion skills cover laravel-security, laravel-tdd, and laravel-verification.

Java Spring Boot patterns; companion skills cover springboot-security, springboot-tdd, and springboot-verification, plus java-coding-standards and jpa-patterns.

Java Quarkus patterns; companion skills cover quarkus-security, quarkus-tdd, and quarkus-verification.

Modern Perl 5.36+ idioms; companion skills cover perl-security (taint mode) and perl-testing (Test2::V0 TDD).

Production ML engineering workflow: data contracts, evals, deployment, and monitoring.

Video and audio pipeline skill: ingest, search, edit, generate, and stream media.

Builds HTML slide decks and converts them to PPTX.

Progressive context refinement for subagents: retrieve, narrow, and re-query instead of dumping everything into context.

Suggests manual context-compaction points during long sessions to preserve what matters.

Architectures for autonomous Claude Code loops, from sequential pipelines and PR loops to DAG-orchestrated multi-agent systems.

Security checklist and guidelines for reviewing code changes.

Integrates the AgentShield security auditor to scan projects.

Audits installed skills and commands for quality and staleness.

Interactive installation wizard for setting up the ECC collection itself.

Long-form writing that avoids generic AI tone.

Multi-platform social content creation and repurposing pipeline.

Source-attributed market and investor research with decision-oriented summaries.

Produces pitch decks, one-pagers, memos, and financial models; investor-outreach adds personalized fundraising outreach.

Patterns to cut the cost of an LLM pipeline: routing each call by complexity, budget tracking and prompt caching.

Decision framework for choosing regex versus LLM parsing on structured text.

iOS 26 Liquid Glass design system for SwiftUI, UIKit, and WidgetKit interfaces.

Swift 6.2 Approachable Concurrency patterns; related skills cover swift-actor-persistence, swift-protocol-di-testing, and foundation-models-on-device (Apple on-device LLM).

Write-time code-quality enforcement using Plankton hooks.

Generate polished HTML presentations using the Reveal.js framework instead of PowerPoint.

Convert markdown documents, chat summaries, or research reports into downloadable EPUB files for Kindle and e-readers.

Spots and rewrites the telltale patterns of AI-written text. Calibrated for English: on French or Spanish text it catches fewer of them.

Gives the agent a real debugger with breakpoints, stepping, variable inspection, and stack traces instead of print-debugging.

General-purpose browser automation with Playwright for scraping, form filling, and end-to-end checks.

Semantic code intelligence via LSP: safe renames, refactors, impact analysis, and verification across a codebase.

Guides Claude to deploy, tune and upgrade a Qdrant vector database: useful if you build a semantic search yourself.

Generate editable AWS architecture diagrams with verified service icons and multiple export formats.

Run safe read-only SQL queries against PostgreSQL databases with multi-connection support.

HashiCorp-maintained skills for Terraform workflows and infrastructure automation.

Extract and analyze HTTP traffic from Charles Proxy session files for API debugging.

Audit UI designs against 17 professional rules (typography, WCAG contrast, spacing) with a score out of 100.

Generate favicons, app icons, and social media images for web projects.

Create data visualizations in d3.js with correct idioms for scales, axes, and transitions.

Lightweight meta-prompting and spec-driven development system for shipping features fast.

Planning copilot that explores the codebase, asks clarifying questions, and generates executable markdown plans.

Guides Claude to write secure code and avoid common vulnerability classes while generating.

Integrates the FFUF web fuzzer and analyzes its results for vulnerabilities during penetration testing.

Code review checklists covering OWASP Top 10:2025, ASVS 5.0, and agentic AI security.

Detect and redact PII from text files across 15 categories with zero dependencies.

Secure environment variable management so secrets never appear in agent sessions or transcripts.

A large set of scientific skills for bioinformatics, cheminformatics, clinical research and machine learning, with specialised libraries and databases.

Searches the academic works indexed by OpenAlex, by keyword or DOI, to find and cite papers.

Automatically profile CSVs: columns, distributions, missing data, and correlations.

Full Kaggle integration: account setup, dataset downloads, competition reports, and submissions.

Visualize and compare GitHub star history as interactive charts with regional breakdown.

Research-backed content writing with citations, improved hooks, and structure.

Computational materials science skills covering numerical stability, time-stepping, and mesh generation.

Build and maintain an LLM-curated personal knowledge base with sharded indexes and search.

Queries and manages your Google NotebookLM notebooks. Unofficial automation of your Google account through a driven browser: needs Python and Playwright, keep it to an account without sensitive data.

Fetch YouTube video transcripts and prepare summaries without watching the video.

Download videos from YouTube and other platforms for offline viewing, editing, or archival.

Improve image quality, especially low-resolution screenshots, before use in docs or sites.

Text-to-speech narration and two-host podcast generation from documents via the ElevenLabs API.

Draft and refine prompts for video generation models such as LTX-2, Sora, and Veo 3.

Automatically sort and rename invoices and receipts for tax preparation.

Turn meeting transcripts into actionable insights about decisions and communication patterns.

Manage Linear issues, projects, and teams via MCP tools, SDK scripts, and GraphQL fallbacks.

Build and test iOS apps through simulator automation from Claude Code.

Official Expo team skills for developing, styling, and deploying Expo React Native apps.

AI-assisted Unity debugging with structured logging, runtime commands, and variable watching.

Drive a self-hosted multi-agent runtime to delegate work across multiple coding CLIs.

Delegate coding tasks (bug fixes, docs, tests) asynchronously to the Google Jules AI agent.

A linter for agent configurations: it validates SKILL.md, CLAUDE.md and hooks, and fixes what it can automatically.

Review recent Claude Code conversations to propose improvements to CLAUDE.md files.

Ambient guidance for creating, modifying, and debugging Claude Code plugins with schemas and templates.

Discovers and installs agent skills matching a plain-language request ("is there a skill that can X"), acting as the entry point to the skills.sh ecosystem.

Vercel's React and Next.js performance rules (rendering, data fetching, bundle hygiene) applied while the agent writes or reviews code.

Gives the agent a driveable headless browser (navigate, click, fill, screenshot) for testing and inspecting live web pages from the CLI.

Matt Pocock's spec-interview skill: the agent interrogates your request with pointed questions to expose vague requirements before writing any code.

Vercel's web interface guidelines for auditing and building UI: accessibility, spacing, states, and interaction details checked against a concrete rule list.

Microsoft's official guidance for building on Azure AI Foundry: models, agents, and deployments via the azure-skills repo.

Official Remotion team rules for authoring programmatic videos in React (compositions, timing, rendering) without common Remotion mistakes.

Variant of grill-me that grounds its interrogation in fetched library documentation, so requirement questions reference real API constraints.

Analyzes an existing codebase's structure and proposes concrete refactors toward better module boundaries and dependency direction.

Enforces a red-green-refactor loop: write the failing test first, implement minimally, refactor, for every feature or fix.

Turns a rough feature idea or conversation into a structured Product Requirements Document ready to hand to implementation.

Official Supabase rules for Postgres schema design, RLS policies, indexing, and query patterns when building on Supabase.

Large searchable UI/UX knowledge pack (named styles, palettes, font pairings, UX rules) used to pick a coherent design direction before building.

ScrapeGraphAI skill that scrapes websites into structured data from natural-language extraction prompts.

Anti-slop frontend skill for landing pages, portfolios, and redesigns: infers the right design direction from the brief and audits before redesigning, with a strict pre-flight check.

Official shadcn/ui skill for installing, composing, and theming registry components correctly instead of hand-rolling lookalikes.

Paul Bakaus’s design language system: a skill, commands and detection rules that spot and fix cheap-looking interfaces.

Defines the exact fonts, spacing, shadows, card structures, and animations of high-end agency work, and blocks the common defaults that make AI designs look generic.

From Corey Haines's marketing skills: runs a structured SEO audit of a site covering technical health, on-page factors, and content gaps.

Writes and edits marketing copy (headlines, landing pages, emails) following direct-response copywriting principles.

Extracts a reusable design system (colors, typography, spacing, component patterns) from an existing site or screenshots.

Emil Kowalski's design-engineering taste for React UI: animation timing, easing, and interaction polish details.

Applies persuasion and behavioral-psychology principles (social proof, loss aversion, framing) to marketing pages and campaigns.

Official Firebase skill covering project setup, SDK integration, and core service usage for apps built on Firebase.

Official Sentry skill for instrumenting apps and managing releases, sourcemaps, and issues through the Sentry CLI.

Plans and scaffolds programmatic SEO: keyword-pattern page templates generated at scale from structured data.

The official Firecrawl skill: crawls and scrapes websites into clean Markdown or structured data. A paid external service billed in credits, with a limited free tier.

Deploys the current project to Vercel with correct project linking and configuration from the CLI.

Optimizes content and site structure for AI answer engines (ChatGPT, Perplexity, Claude) rather than classic SERPs.

Official browser-use skill: autonomous browser automation (navigate, interact, extract) driven by the agent.

Microsoft's official Playwright CLI skill for scripting browser automation and end-to-end tests.

A structured code review: security, logic, performance and style.

Analyzes staged git changes and writes conventional-commit messages matching the actual diff.

Scans a project's structure and generates a complete README.md (features, setup, usage).

Systematically diagnoses why a project will not start: env vars, versions, ports, and dependency mismatches.

Reviews database migration files for destructive or locking operations before they reach production.

Converts any documentation website into an installable Claude skill automatically.

Fetches Reddit threads and comments when normal WebFetch returns 403 errors.

Lets the agent chat directly with Google NotebookLM for source-grounded answers over uploaded documents.

Automatically creates user-facing changelogs from git commit history.

Recommends matching Claude Academy (academy.claude.com) courses, tutorials, and use cases whenever a user asks how to use Claude or a Claude product, composing with product documentation answers rather than replacing them.

After a substantive answer or draft the user may act on, appends two to three short follow-up questions tied to specific claims in that answer, to help the user check facts, probe the reasoning, and notice missing context; at most once per conversation.