Plugins & Tools
MCP servers, Claude Code plugins and skills, and the CLI tools worth wiring up. What each does and how to get it.
12 entries
Reads and writes real GitHub state from your editor. It opens and reviews pull requests, files and comments on issues, reads file contents across branches, searches code, and inspects Actions run logs so you can debug a failed CI job without leaving the chat. Anthropic's own reference server, so it tracks the spec closely.
GET · Add the hosted server URL to your MCP client config, or run the Docker image locally, then authorize with a GitHub token or OAuth.
Gives the model scoped read and write access to a folder you choose on disk. It lists directories, reads and edits files, moves and renames them, and searches contents, all fenced to the roots you allow so it can't wander into the rest of your machine. This is the workhorse most local agent setups start with.
GET · Add to your MCP client config with the allowed directory paths passed as arguments. Runs locally over stdio, no network account needed.
Connects to a Postgres database and runs queries so the model can answer questions about your actual data, inspect table schemas, and explain a slow query. The reference build is read-only by default, which keeps an eager agent from dropping a table while it's exploring.
GET · Add to your MCP client config with a connection string. Runs locally and talks to any reachable Postgres instance.
Drives a full Supabase project from chat: list tables, run SQL, apply migrations, deploy edge functions, pull logs, and run the security and performance advisors. It also generates TypeScript types from your schema, which saves a round trip when you're wiring up a client. Handy when you want the agent to both diagnose and fix a schema issue in one pass.
GET · Add the Supabase MCP server to your client config and authorize with a project access token.
Lets the model drive a real browser through Playwright. It navigates pages, clicks and fills forms, waits for elements, and grabs screenshots or the accessibility tree, so you can have it reproduce a bug, scrape a rendered page, or verify a deployed UI actually renders. Microsoft maintains it, and it works against Chromium, Firefox, and WebKit.
GET · Add to your MCP client config. Installs the browser binaries on first run; no account required.
Reads and posts to Slack. It lists channels, fetches recent history, searches messages, posts and threads replies, and adds reactions, so an agent can summarize what happened in a channel overnight or drop a build-status note where the team will see it. Common glue between a coding agent and the humans watching it.
GET · Add to your MCP client config with a Slack bot token, or install through a hosted connector that handles the OAuth for you.
Pulls live error data from Sentry so the model can look at the actual stack trace instead of guessing. It fetches issue details, the events under an issue, and breadcrumbs, and its Seer feature can suggest a root cause, so you can go from an alert to a candidate fix in the same conversation.
GET · Use the hosted Sentry MCP endpoint with OAuth, or run it locally with an auth token. Add the URL to your MCP client config.
Talks to the Stripe API from chat. It looks up customers, creates payment links and invoices, lists charges and subscriptions, issues refunds, and can search the Stripe docs when you're unsure which call to make. Useful for support triage and for wiring billing into an app without tabbing into the dashboard.
GET · Add to your MCP client config with a Stripe API key. Start with a restricted or test-mode key so the agent can't touch live money by accident.
Reads and writes your Notion workspace. It searches pages and databases, creates and updates pages, appends blocks, and queries database rows, so an agent can turn a scattered thread into a structured doc or file a spec into the right database without you copy-pasting.
GET · Add the official Notion MCP server (hosted or local) to your client config and connect through Notion's OAuth, granting access to the pages you want it to touch.
Manages Linear issues from the model. It searches issues, creates and updates them, sets status and assignee, and reads project and cycle context, so a coding agent can open the ticket for the bug it just found or move a task to done when it ships the fix. Keeps engineering work and the tracker in sync.
GET · Add Linear's official MCP server to your client config and authorize with OAuth. Hosted endpoint available.
Fetches a URL and hands back clean, readable content instead of raw HTML soup. It converts a page to markdown so the model can actually reason over it, which is the cheapest way to give an agent current web context without a full browser stack. The go-to when you just need the text of a page.
GET · Add to your MCP client config. Runs locally over stdio, no account needed.
Bridges Figma and code in both directions. It reads a frame's design context, variables, and screenshots so an agent can implement a screen faithfully, and it can push generated layouts back into a Figma file. Also maps Figma components to your codebase via Code Connect, which keeps a design system from drifting away from the code.
GET · Run the Figma desktop app's MCP server or add the hosted endpoint to your client config, then connect your Figma account.
25 entries
Reads and writes real PDFs from the command line. It pulls text and tables out of scanned or generated files, fills form fields, splits and merges documents, and can build a PDF from scratch. This is the skill Claude reaches for when you hand it a contract and ask what page 12 actually says.
GET · Ships with Claude via the anthropic-skills pack, or add from github.com/anthropics/skills. In Claude Code it surfaces as anthropic-skills:pdf.
Creates and edits Word documents while keeping tracked changes, comments, styles, and headers intact. You can ask for a redline of a vendor agreement and get back a .docx a lawyer can open without the formatting falling apart.
GET · Part of the anthropic-skills pack; source at github.com/anthropics/skills. Appears as anthropic-skills:docx.
Builds and edits PowerPoint decks with real layouts, speaker notes, and brand colors instead of a wall of bullet points. Hand it a rough outline and it returns an actual .pptx you can present.
GET · Part of the anthropic-skills pack (github.com/anthropics/skills), shown as anthropic-skills:pptx.
Works inside Excel workbooks: adds columns with live formulas, builds pivot-style summaries, and preserves the cell formatting people care about. Good when you want a calculation added to a spreadsheet, not a CSV dumped next to it.
GET · Part of the anthropic-skills pack (github.com/anthropics/skills), shown as anthropic-skills:xlsx.
Walks you through writing your own skill: it scaffolds the folder, drafts the SKILL.md frontmatter and instructions, and helps you pick trigger phrases that actually fire. The fastest way to turn a repetitive prompt of yours into something reusable.
GET · In the anthropic-skills pack as anthropic-skills:skill-creator. Reference source: github.com/anthropics/skills/tree/main/skills/skill-creator.
Helps you design and build an MCP server from a spec: it lays out the tool definitions, wires the request handlers, and gets you to a server Claude can actually connect to. Handy when you want to expose your own API as tools rather than pasting docs into context.
GET · In the anthropic-skills pack as anthropic-skills:mcp-builder.
Produces polished visual layouts and canvas-style artwork with real design decisions behind them, not the flat gradient-blob look you get from a naive prompt. Reach for it when you want a poster, a diagram, or a hero graphic that looks intentional.
GET · In the anthropic-skills pack as anthropic-skills:canvas-design.
Generates generative and algorithmic art (particle fields, flow patterns, geometric systems) as code you can tweak and re-run. Fun for cover images, backgrounds, or a deterministic piece you want to render frame by frame.
GET · In the anthropic-skills pack as anthropic-skills:algorithmic-art.
Applies a set of brand rules (colors, type, spacing, logo usage) to whatever you are making so the output stays on-brand. Pair it with a design task and it stops the model from inventing its own palette halfway through.
GET · In the anthropic-skills pack as anthropic-skills:brand-guidelines.
Spins up a full visual theme (color tokens, typography scale, component styling) from a short brief, so a new project starts with a coherent look instead of default browser gray. Useful right before you build a landing page or dashboard.
GET · In the anthropic-skills pack as anthropic-skills:theme-factory.
Builds self-contained, interactive web artifacts (calculators, mini-apps, visualizations) as single files that run without a build step. Good for a quick tool you want to hand someone as one HTML file they can just open.
GET · In the anthropic-skills pack as anthropic-skills:web-artifacts-builder.
Writes production-grade frontend code with actual design taste: distinctive components and pages that dodge the generic AI-template aesthetic. Use it when you ask Claude to build a UI and you care whether it looks shipped or looks auto-generated.
GET · Available in Claude Code as the frontend-design skill (invoke by asking to build a component, page, or app).
Runs a real research pass: it fans out multiple web searches, fetches the sources, argues against its own findings to catch weak claims, then writes a cited report. This is the one to use when a single search is not enough and you need something you can defend.
GET · Available in Claude Code as the deep-research skill. Pass it a specific, scoped question as the argument.
A bundle of engineering workflows: code review, debugging, system design, architecture write-ups, deploy checklists, incident response, tech-debt triage, testing strategy, and standups. Each one is a focused command so you are not re-explaining what a good code review looks like every time.
GET · Install from the official marketplace: /plugin install engineering@claude-plugins-official. Surfaces skills like engineering:code-review and engineering:incident-response.
Everything for working a dataset end to end: write and run SQL, explore and validate data, run statistical analysis, and build charts or dashboards. It also has a context-extractor that reads your schema first so the queries it writes actually match your columns.
GET · /plugin install data@claude-plugins-official. Includes data:write-query, data:statistical-analysis, data:build-dashboard, and more.
Drafts channel-specific content (blog, social, email, landing pages, press releases), plans full campaigns with a week-by-week calendar, runs an SEO audit, builds multi-email drip sequences, and reviews copy against your brand voice before it ships. The brand-review step flags unsubstantiated claims and missing disclaimers, which saves an awkward legal conversation later.
GET · /plugin install marketing@claude-plugins-official. Includes marketing:campaign-plan, marketing:email-sequence, marketing:seo-audit, marketing:brand-review.
PM workflows from idea to shipped: brainstorm a problem space with a sharp sparring partner, write a spec or PRD, plan a sprint against real capacity (PTO and meetings included), update a Now/Next/Later roadmap, run a metrics review, and synthesize a pile of user interviews into ranked insights.
GET · /plugin install product-management@claude-plugins-official. Includes product-management:write-spec, product-management:sprint-planning, product-management:synthesize-research.
Preps a rep for the day: account research, call prep and call summaries, pipeline review, forecasting, competitive intelligence, and drafting outreach that reads like a person wrote it. The daily-briefing command rolls your accounts and calls into one morning read.
GET · /plugin install sales@claude-plugins-official. Includes sales:call-prep, sales:pipeline-review, sales:draft-outreach, sales:forecast.
In-house legal workflows with escalation baked in: triage an incoming NDA to green/yellow/red, review a contract against your playbook and generate redlines, run a compliance check on a proposed launch, and route documents for signature with a pre-flight checklist. It knows when a matter is too hot for a templated reply and says so.
GET · /plugin install legal@claude-plugins-official. Includes legal:triage-nda, legal:review-contract, legal:compliance-check, legal:signature-request.
Accounting and FP&A close work: run the month-end close with task sequencing and dependencies, prep journal entries, reconcile accounts, run variance analysis, and support SOX testing and audits. The close-management command tracks where the close is stuck day by day instead of living in a spreadsheet nobody updates.
GET · /plugin install finance@claude-plugins-official. Includes finance:close-management, finance:reconciliation, finance:variance-analysis, finance:sox-testing.
People-ops tasks from hire to review: build competency-based interview plans and scorecards, draft an offer with a full comp package, benchmark pay and model equity, run onboarding checklists with 30/60/90 goals, and structure performance reviews with calibration prep. There is also a plain-language policy lookup for the PTO question you get asked twice a week.
GET · /plugin install human-resources@claude-plugins-official. Includes human-resources:interview-prep, human-resources:draft-offer, human-resources:comp-analysis, human-resources:onboarding.
Product design and UX craft: run a design critique, do an accessibility review, build or extend a design system, prep a clean design-to-dev handoff, write UX copy, and structure user research plus its synthesis. Good for keeping design rigor in the loop when engineers are the ones driving.
GET · /plugin install design@claude-plugins-official. Includes design:design-critique, design:accessibility-review, design:design-system, design:ux-copy.
Business and ops muscle: document a process with flowcharts and a RACI, write runbooks that turn tribal knowledge into exact steps, plan capacity and forecast utilization, run risk assessments and change requests with rollback plans, and track compliance for SOC 2 or GDPR. The status-report command turns a messy tracker into something leadership will actually read.
GET · /plugin install operations@claude-plugins-official. Includes operations:runbook, operations:process-doc, operations:risk-assessment, operations:capacity-plan.
Frontline support workflows: triage and prioritize a ticket (P1 to P4, dedupe against known issues), research a customer question across sources, draft a response tuned to the relationship and the situation, package an escalation to engineering with full context, and turn a solved ticket into a knowledge-base article.
GET · /plugin install customer-support@claude-plugins-official. Includes customer-support:ticket-triage, customer-support:draft-response, customer-support:customer-escalation, customer-support:kb-article.
A two-tier memory and task system that lets Claude work like a colleague who knows your shorthand. It decodes your nicknames, acronyms, and project codenames, keeps working memory in CLAUDE.md and the full knowledge base in a memory directory, and manages tasks in a shared TASKS.md. Set it up once and requests stop needing a glossary.
GET · /plugin install productivity@claude-plugins-official. Includes productivity:start, productivity:memory-management, productivity:task-management, productivity:update.
16 entries
Tracks every change to your code so you can branch, diff, revert, and see who broke what. When an AI agent rewrites half a file, `git diff` shows you exactly what moved before you commit, and `git checkout .` throws it all away if the agent went sideways. It's the safety net under every other tool here.
GET · Preinstalled on most Macs and Linux boxes. Check with `git --version`. On macOS run `brew install git`, on Debian or Ubuntu `apt install git`, or grab an installer from git-scm.com. Then set your name and email with `git config --global user.name` and `user.email`.
Runs GitHub from your terminal, so you never tab over to the browser to open a PR. `gh pr create` ships a pull request, `gh pr checks` watches CI go green or red, `gh run view --log-failed` pulls the exact failing test output, and `gh api` hits any REST or GraphQL endpoint. Agents lean on it hard because it turns GitHub into scriptable commands.
GET · `brew install gh` on macOS, `apt install gh` on Debian or Ubuntu, or download from cli.github.com. Run `gh auth login` once and pick browser or token. Confirm it worked with `gh auth status`.
Searches your whole codebase for a string or regex in the time it takes to blink, and it respects .gitignore so you're not wading through node_modules. `rg "createClient"` finds every call site instantly. It's the search engine most coding agents reach for because grep-across-a-repo is the single most common thing they do.
GET · `brew install ripgrep` on macOS, `apt install ripgrep` on newer Debian or Ubuntu, `cargo install ripgrep` if you have Rust, or grab a binary from the BurntSushi/ripgrep GitHub releases. The command is `rg`.
Drives a real Chromium, Firefox, or WebKit browser from code, so you can click through your app, fill forms, and screenshot pages headlessly. `npx playwright screenshot --viewport-size=390,844 https://yoursite.com shot.png` gives you a mobile render you can actually look at. When you need proof a page renders correctly instead of trusting an HTTP 200, this is how you get it.
GET · `npm init playwright@latest` scaffolds a project, or `npx playwright install` just to pull the browser binaries. For one-off screenshots you can run `npx playwright screenshot <url> <file>` with no setup. Needs Node 18 or later.
The swiss army knife for video and audio on the command line. It transcodes formats, trims and stitches clips, stamps captions on, extracts frames, and turns a folder of PNGs into an MP4. If your AI workflow generates reels or animations, this is what renders the frames into a shareable file (`ffmpeg -framerate 30 -i frame_%04d.png out.mp4`).
GET · `brew install ffmpeg` on macOS, `apt install ffmpeg` on Debian or Ubuntu, or download static builds from ffmpeg.org. Verify with `ffmpeg -version`. The static builds bundle most codecs you'll want.
Deploys and manages Vercel projects from the terminal. `vercel` pushes a preview URL, `vercel --prod` promotes to production, `vercel logs <url>` tails the runtime logs when a serverless function is throwing, and `vercel env pull` drops your environment variables into a local .env. Handy for Next.js apps where you want to ship without leaving your editor.
GET · `npm i -g vercel` (or `pnpm add -g vercel`). Run `vercel login` to authenticate, then `vercel link` inside a project folder to connect it. Needs Node 18 or later.
Manages your Supabase Postgres project locally and in the cloud. `supabase migration new` scaffolds a versioned SQL migration, `supabase db push` applies it, `supabase gen types typescript` generates types straight from your schema, and `supabase start` spins up the whole stack in Docker for offline dev. This is how you keep database changes in git instead of clicking around a dashboard.
GET · `brew install supabase/tap/supabase` on macOS, `npm i -g supabase`, or `scoop install supabase` on Windows. Run `supabase login` with an access token, then `supabase link --project-ref <ref>` to connect a project.
Lets you build and test Stripe payments without a live card. `stripe listen --forward-to localhost:3000/webhook` pipes real webhook events to your local server so you can debug them, `stripe trigger payment_intent.succeeded` fakes an event on demand, and `stripe logs tail` streams API request logs. Removes the usual pain of testing a checkout flow that only fires after a real purchase.
GET · `brew install stripe/stripe-cli/stripe` on macOS, download from the stripe/stripe-cli GitHub releases, or use the Docker image. Run `stripe login` to pair it with your account through the browser.
Slices JSON on the command line so you can pull one field out of a fat API response without writing a script. `curl api.example.com/users | jq '.data[].email'` gets you every email from a nested payload. Once you're piping curl into things, jq is the piece that makes the output readable and filterable.
GET · `brew install jq` on macOS, `apt install jq` on Debian or Ubuntu, or download a single static binary from jqlang.github.io/jq. No runtime needed, it's a standalone binary.
Packages an app and everything it needs into a container that runs the same on your laptop and on a server. `docker compose up` boots a Postgres, a Redis, and your API together with one command, so a new machine goes from zero to running in minutes. It's also what a lot of local dev stacks (Supabase included) run on underneath.
GET · Install Docker Desktop from docker.com on macOS or Windows, or `apt install docker.io` plus the compose plugin on Linux. Check with `docker --version` and `docker compose version`. On Linux add yourself to the docker group so you can skip sudo.
Fires HTTP requests from the terminal, which makes it the fastest way to poke an API or check whether an endpoint is actually alive. `curl -s -o /dev/null -w '%{http_code}' https://yoursite.com` returns just the status code, and pairing `curl` with `jq` handles most quick API debugging without opening Postman. Agents use it constantly to verify a deploy actually serves the right body.
GET · Already on macOS and virtually every Linux box. Confirm with `curl --version`. If you somehow don't have it, `brew install curl` or `apt install curl`.
A fast Node package manager that stores one copy of each dependency on disk and hard-links it into projects, so installs are quick and your disk isn't buried under twenty copies of React. `pnpm install` is noticeably faster than npm on a cold cache, and its workspace support makes monorepos far less painful. Drop-in replacement for npm and yarn commands.
GET · `brew install pnpm` on macOS, `npm i -g pnpm`, or `corepack enable pnpm` if you're on a recent Node. Verify with `pnpm --version`.
Where the team lives, and where you want build notifications, deploy alerts, and agent status pings to land. Wire an incoming webhook and a CI run or a finished agent task can post straight into a channel with a link to the PR. The API also lets you read threads and post threaded replies, so a bot can summarize a channel or answer in context.
GET · Create a Slack app at api.slack.com/apps, add an Incoming Webhook or a Bot Token with the scopes you need (chat:write, channels:history), and install it to your workspace. POST JSON to the webhook URL to send a message. For richer use, an MCP server or the official SDK wraps the Web API.
Doubles as a database and a doc store, which makes it a nice home for AI-generated specs, launch plans, and structured content an agent needs to read or write. The API treats pages and database rows as JSON, so a workflow can create a page, update a status property, or pull the whole knowledge base into a prompt. Good fit when humans and agents both need to touch the same content.
GET · Create an integration at notion.so/my-integrations, copy the internal integration token, then share the specific pages or databases with that integration from inside Notion. Call the REST API at api.notion.com with the token, or use the @notionhq/client SDK or a Notion MCP server.
The design source of truth, and increasingly a machine-readable one. The API and the Dev Mode MCP server hand an agent the actual layout, spacing, colors, and variable tokens from a frame, so it can generate components that match the design instead of eyeballing a screenshot. Closes the gap between what a designer drew and what gets shipped in code.
GET · For the REST API, generate a personal access token in Figma under Settings, Security, then call api.figma.com with the file key from the URL. For live design context in your editor, enable the Dev Mode MCP server in the Figma desktop app (Preferences) and point your MCP client at it.
Issue tracking that engineering teams actually enjoy, with a fast GraphQL API that agents can drive. A workflow can open an issue when a test fails, move a ticket to In Review when a PR opens, or pull the backlog to decide what to work on next. Its clean data model makes it easier to automate than heavier trackers.
GET · Grab a personal API key from Linear under Settings, Security and access, or set up an OAuth app for multi-user access. Hit the GraphQL endpoint at api.linear.app/graphql, or use the @linear/sdk package or the Linear MCP server for a friendlier interface.
New prompts, skills and tools land here first. One email, no noise, unsubscribe in a click.
Free. No spam. Unsubscribe any time.