Everything you can build with AI

Turns a UI request into a design and code with a clear visual personality, with care for layout, typography, color and detail.

Creates a new skill or improves an existing one, and helps set up evals that measure the quality and reliability of its results.

Tests a local web app with Playwright: checks behavior, screenshots and browser logs. Needs the app running and a browser.

Reviews your CLAUDE.md files and improves project instructions so they are clear, consistent and fit the codebase.

Reviews and speeds up React and Next.js apps: fewer request waterfalls, smaller bundles and no needless re-renders.

Reviews web interfaces against usability, accessibility and interaction-quality guidelines, with notes tied to the code.

Turns a rough idea into requirements, options and an agreed design before any code is written.

Finds the root cause with hypotheses, evidence and reproduction instead of random fixes.

Reviews your changed code for reuse, simplification and efficiency, then applies the cleanups.

Reviews the current diff or a PR for correctness bugs at the effort level you choose, and can post or fix the findings.

Runs a full security review of the pending changes on your branch.

Creates a CLAUDE.md file that documents your codebase for Claude.

Runs a prompt or slash command on a repeating interval, for example to keep checking a deploy.

Creates scheduled cloud agents that run on a cron schedule, or once at a set time.

Scans your sessions for common safe commands and adds them to an allowlist, so you see fewer permission prompts.

Configures Claude Code settings: hooks, permissions and environment variables.

Launches and drives your app to show a change working in the real app, not just in tests.

Runs the red-green-refactor loop: write a failing test, make it pass with the minimum code, then clean up with tests still green.

Requires fresh test or build evidence before the agent may say a task is done or a bug is fixed.

Turns requirements into a small-step implementation plan that lists the files, changes and tests needed.

Helps pick a design system, colors, fonts, UX patterns and accessibility for web and mobile, using a searchable local dataset.

Guides building Claude apps with the SDK: tool use, streaming and prompt caching. Running the API needs an account and credit.

Co-writes specs, proposals and docs: gathers context, drafts, then sharpens clarity for the reader.

Creates and edits Word documents, their formatting, tables and templates, and works with their content in code.

Explains how to design an MCP server and its tools so an agent can use outside services, in Python or TypeScript.

Reads PDFs and extracts text and tables; merges and splits pages; handles forms and OCR with the available tools.

Creates and edits PowerPoint decks: slides, templates and layout, not just the talk text.

Builds rich web artifacts with React, Tailwind and UI components. Needs build tools; output can vary by environment.

Creates and edits spreadsheets, formulas and charts, and cleans and converts data between supported formats.

Reviews PostgreSQL schema, queries, indexes, RLS policies and performance. Useful even outside Supabase hosting.

Chooses between a local or remote MCP server and guides building and packaging it, with the rest of the mcp-server-dev plugin.

Scans your project and recommends fitting skills, agents, hooks and MCP servers. Advice only; still review permissions.

Explains how to build a skill inside a plugin, write its trigger description and split knowledge into a short entry plus references.

Builds an interactive HTML dashboard with charts, tables and filters to show metrics and analysis results.

Makes Python charts and picks the right chart type, with care for readability, color and accessibility.

Merges findings from many sources into one connected summary without repetition, with attribution, confidence and limits.

Splits a question into the right queries for each source and ranks the results. Multi-source search needs the right connectors.

Writes and optimizes SQL and translates it between database dialects, including CTEs, window functions and aggregation.

Checks an analysis for sound method, correct math and bias before you share it or act on it.

Turns a feature idea into a PRD: problem, goals, out of scope, success metrics and acceptance criteria.

Runs exploratory testing on a web app and writes a bug report with repro steps and screenshots or video. Needs agent-browser.

Finds skills that fit your task and explains how to install them with the Skills CLI. A discovery tool, not a safety rating.

Designs composable, reusable React components and keeps component APIs simple instead of piling on props.

Improves React Native and Expo apps: lists, interactions and platform best practices for speed and quality.

Carries out a plan in clear phases with a review after each one. Most useful once planning is finished.

Helps you understand reviewer feedback and verify it technically before accepting and applying it.

Prepares a structured review request for your changes, especially before a merge or after a major step.

Runs a development plan with sub-agents and staged reviews, keeping implementation and evaluation separate.

Isolates work in its own Git worktree, with checks on the path and a safe project setup.

Writes and reviews procedural skills and tests them against real usage scenarios. A method-driven alternative to Anthropic's skill-creator.

A way to design modules with simple interfaces and deep internals, which makes code easier to test and understand.

Sets up hooks that block dangerous Git commands before they run. Review the rules: they can also block wanted commands like push.

Grills you with tough questions to expose weak assumptions and gaps in a plan or design before you build it.

Finds ways to improve your codebase structure, shows them in an HTML report, then discusses the chosen option in depth.

Structures REST API design: resource naming, status codes, pagination, versioning and rate limits.

Guides the structure of Node.js, Express and Next.js apps, their services and data access.

Sets shared naming, organization and readability rules across a project, with practical habits that cut complexity.

Plans safe database migrations: gradual changes, indexes and data backfills without assuming downtime.

Helps set up Docker, Compose, networks, volumes and production-ready images.

Builds end-to-end Playwright tests: page objects, CI setup and handling flaky tests.

Builds an eval harness for capabilities and regressions, with metrics, graders and repeatable tests.

Reviews auth, input handling, secrets and APIs before release, using a practical security checklist.

Builds Gradio UIs in Python for models and chat demos, with components, events and layout.

Helps pick a GGUF model and run it locally with llama.cpp to fit your RAM, CPU or GPU, plus a compatible server.

Builds a precise picture of code flow, assumptions and dependencies before a security audit, so findings have context.

Security-reviews a code diff: blast radius of the change, regression risk and missing tests.

Sets up Python projects with modern tools such as uv, Ruff and ty, with clean dependencies and checks.

Designs property-based tests that generate many cases and check invariants, instead of a few hand-written examples.

Runs and guides Semgrep code scans and triages the results. Some features are optional paid extras.

Spots APIs and settings that are easy to misuse or that invite security mistakes.

Audits dependency and supply-chain risk from lockfiles, advisories, install behavior and publisher signals.

Builds a tracking plan for events and conversions and checks your GA4 (or similar) setup. Needs data access.

Plans topics, content pillars, clusters and a publishing calendar around your audience and product goals.

Writes and improves sales pages, product copy, headlines and calls to action, focused on clear value.

Diagnoses technical, on-page and indexing SEO problems and turns them into fixes. Rankings are never guaranteed.

Explores local data files and flags missing values, leakage and anomalies.

Runs literature reviews: searching, screening and citation checks across scholarly sources, with coverage limits noted.

Weighs scientific claims: study design, bias, confounders and how far the conclusions really reach.

Helps choose the right statistical test, check its assumptions, effect size and power, and report results.

Makes generative art with p5.js, seeded randomness you can reproduce, and controls to explore variations.

Creates original static visuals such as posters and art pieces as PNG or PDF.

Designs and reviews REST and GraphQL APIs for clarity, consistency, scale and easy maintenance.

Applies Clean Architecture, Hexagonal Architecture and DDD to organize boundaries, dependencies and services.

Sets up GitHub Actions for test, build and deploy, with reusable templates and a review of secrets and permissions.

Guides generics, conditional and mapped types and template literals in TypeScript for safer APIs at compile time.

Diagnoses slow loading and interaction using Core Web Vitals and Lighthouse data.

Reviews Cloudflare Workers code and config and applies production best practices.

Handles data fetching, caching, errors, loading states and offline mode with the right React tools.

Organizes Expo navigation: file-based routes, tabs, nested stacks, modals and headers.

Guides work with Supabase Auth, Database, Storage, Realtime and Edge Functions. Needs a connection and access.

Reviews a PR or diff for bugs, regressions, missing tests and broken conventions.

Runs a diagnosis loop for broken or slow behavior: investigate and verify before changing code.

Builds a structured plan for multi-step work, code or not, from clear requirements.

Carries out a plan or clear build request and verifies it locally, inside the Compound Engineering plugin.

Guides creating plugin agents: their instructions, when they are called and which tools they need.

Helps build an MCP App that shows an interactive UI inside the client. Needs a client that supports MCP Apps.

Helps write plugin slash commands, their arguments and metadata, and wire them into a workflow.

Builds hooks on Claude Code events, such as checking a tool call or enforcing a rule before it runs.

Connects MCP servers to a Claude Code plugin and explains connection, transports and configuration.

Makes an interactive HTML playground with controls and live preview to try an idea or settings and copy the result.

Lays out a Claude Code plugin: manifest plus folders for commands, agents and skills.

Tracks simple tasks and commitments in a shared TASKS.md file: add, update and mark done.

Entry point to create, edit and check HyperFrames videos; picks the workflow and skills you need.

Builds scene, text and transition motion with GSAP and other engines on a seekable, deterministic timeline.

Mixes audio already in the project: levels, fades, ducking music under voice, and effects.

Guides the build, preview, check and render loop for HyperFrames video, locally or in the cloud.

Sets the HTML composition structure, timing, tracks and media playback so a HyperFrames project renders reliably.

Plans look, palette, fonts, story and pacing for HyperFrames videos; art direction rather than motion code.

Builds camera moves, zooms, reframes and 2D/3D keyframes that render deterministically.

Searches the HyperFrames registry for ready-made visual blocks and shows how to wire them in.

Prepares media, audio, voiceover, transcripts and assets for a HyperFrames project and logs them.

Guides browser automation with the agent-browser CLI. The skill file alone does not install the browser engine.

Guides deploying a project to Vercel and getting a preview or production link. Needs the service set up.

Analyzes the speed and cost of a Vercel project from its real data. Needs the CLI and a linked project.

Splits independent problems across parallel agents and merges the results. Can use more tokens.

Wraps up a development branch once tests pass, with clear choices to merge, open a review or park the work.

Turns the current discussion into a spec and posts it to your issue tracker.

Breaks a plan or spec into linked tickets that show blockers and dependencies.

Designs an LLM pipeline with model routing, budgets, retries and caching to cut waste.

Downloads and uploads models, datasets and Spaces with the official Hugging Face CLI.

Explores Hugging Face datasets via the Dataset Viewer: splits, rows, search, filters, Parquet and stats.

Guides fine-tuning with TRL or Unsloth on Hugging Face Jobs, including data prep, hardware and cost. GPUs may be paid.

Builds, fixes and deploys Hugging Face Spaces with Gradio, Docker or static pages.

Audits GitHub Actions that use AI agents, especially the risk of untrusted input reaching the agent.

Guides data-flow and vulnerability analysis with CodeQL. Needs the tool and a database for your code.

Writes custom Semgrep rules with examples and tests to prove they catch the intended pattern.

After one bug is found, hunts for other copies of the same flaw across the codebase.

Adds transcripts and animated word-by-word captions to Remotion videos.

Starts a new video in Remotion and React with a clean project and component structure.

Guides rendering a Remotion composition to a video file.

Reviews how well your content can be understood and cited by AI search and answer engines.

Edits existing marketing copy: cuts filler, sharpens clarity and tone, and updates stale facts.

Reviews marketing pages and forms for conversion blockers and suggests fixes and tests.

Plans a product or feature launch: messaging, pre-launch steps, channels and a readiness check.

Helps analyze plans, pricing, value metrics and free trials based on your market and customers.

Plans programmatic SEO pages built from templates and data, with real value on every page.

Looks up reference data, checks DOIs and citations and prepares BibTeX.

Writes and reviews scientific reports and papers with evidence tracking and consistent sections.

Drafts status updates, newsletters, incident summaries and internal messages in practical company formats.

Makes GIFs that fit Slack's size, dimension and motion limits.

Applies a matching color and font theme to decks, documents and web pages, or creates a new theme.

Builds and debugs agent apps on the Cloudflare Agents SDK.

Picks the right Cloudflare services for your app and points to their docs and skills.

Builds and reviews Durable Objects for persistent state and coordination in Cloudflare apps.

Runs and fixes Wrangler commands for dev, preview, deploy and resource management.

Writes and explains EAS Workflows that automate build, test and distribution for Expo projects.

Builds Expo UIs that feel native, with semantic colors, icons, controls and responsive layout.

Guides Expo SDK upgrades and fixes dependency conflicts between versions.

Saves the non-obvious lessons from a solved, verified problem into repo docs for future tasks.

Packages an MCP server as a distributable MCPB bundle with dependencies and install setup.

Organizes local, customizable plugin settings without mixing each user's settings into shared project files.

Pulls clean content from a known URL or structured data from a site. Needs the Firecrawl CLI and credit.

Searches the web, fetches relevant snippets and discovers tools and data sources. Needs the Firecrawl CLI and API.

Controls Electron apps through CDP and agent-browser.

Suggests compacting the conversation at natural phase boundaries to keep long sessions on track.

Logs, views and analyzes ML experiment metrics with Trackio, with dashboards and alerts.

Checks sensitive and crypto code for timing leaks, where run time reveals secret data. A defensive specialist skill.

Reads, merges and filters SARIF reports from scanning tools.

Entry point that routes to the specialized Remotion skills in the current version.

Builds animated map scenes with supported map providers. Some providers need an API key.

Uses Mediabunny to inspect media and work with video and audio files in code.

Prepares and submits iOS and Android builds to the app stores, including signing and versions.

Entry point for the Superpowers pack: picks the right skills and the order to use them in.

Applies Anthropic's official brand colors and typography to artifacts, a good template for building your own brand skill.

Points people asking how to use Claude to matching courses, tutorials and use cases on Claude Academy.

After advice, drafts or analysis you may act on, adds a short nudge on what to double-check before relying on it.

Scans a whole repo or just your changes for security issues and can suggest verified patch files you apply yourself.

Writes Hookify rules that warn about or block risky actions in Claude Code, with the rule syntax and patterns.

Builds an explorable HTML report of your Claude Code usage: tokens, cache, sub-agents, skills and expensive prompts.

Creates a personal Claude Code usage and impact report from your local sessions and git history.

Generates a tabbed project status page: overview, workstreams, next steps, risks and decisions.