All Plugins

GitHub PR Assistant reads pull request metadata, fetches diffs and file lists, pulls CI and check run statuses, and reads recent conversation threads. It maps changed files to paths and languages so you can see which modules and teams are affected, and it checks commit history for context like recent refactors or dependency bumps. The connector uses the GitHub API to read labels, branch names, base commits, linked issues, and available merge methods. It generates a concise, human-readable summary of what changed, extracts TODOs and potential breaking changes, and suggests a short PR description and changelog entry you can paste or commit back into the body. The assistant posts that as a PR comment or updates the body, recommends reviewers based on CODEOWNERS and recent committers, adds or removes labels, and emits a review checklist that lists files to inspect and tests to run. The tool watches PR events and updates summaries when new commits land, highlights failing CI jobs and the files touched by those failures, and flags large binary additions or common sensitive patterns like exposed keys or changed licenses. It can open follow-up issues from extracted TODOs, add inline comments with code snippets or suggested fixes, and attach a short risk assessment so reviewers focus on the risky areas first. Say you open a review for a feature with 120 changed files: the assistant reads the diff, posts a short summary and checklist, recommends two reviewers, and calls out the single failing test and the files it touched. That saves you the back-and-forth between GitHub, CI, and your local editor and lets the team start targeted reviews without switching tools.

Integrate Snyk vulnerability scanning directly into your Claude Code workflow. Get real-time security alerts, dependency vulnerability reports, and AI-suggested fixes without leaving your terminal.Supports Node.js, Python, Go, Java, and more.

Linear Issues connects Claude Code to your Linear workspace and runs queries, creates and updates issues through the Linear API. It reads full issue data (title, description, state, assignee, labels, priority, custom fields), pulls comments and timeline entries, and maps workspace IDs to human-friendly names. For the original code and setup see https://github.com/wrsmith108/linear-claude-skill. Use it to search by project, team, label or explicit GraphQL filter, to create new issues with a description and linked metadata, to post comments, to change state or assign owners. It runs GraphQL mutations and returns normalized JSON so your code can apply bulk updates, filter results, or render a compact list of matches. It converts conversational instructions into specific Linear mutations: extract title, estimate, priority and assignee, find the target issue by number or query, and run the update. The plugin reports API errors, missing permissions, and supports a dry-run mode so you can preview changes before they land. For example, when a QA engineer drops a bug summary into chat you can run a single command to create the issue, set priority, assign to the right team and post the initial comment — avoiding a switch to the Linear web UI and saving minutes per report.

Slack Messenger connects your Claude Code workflows to a Slack workspace using a bot token or OAuth. It reads channel lists and metadata, posts messages and rich block layouts, uploads files, posts into threads, sets channel topics, and adds or removes reactions. You can send ephemeral messages to specific users and target messages to channels by name or ID. Call actions to send plain text, formatted blocks, or legacy attachments, schedule messages, edit or delete previous posts, and fetch conversation history or a specific thread. The plugin receives Events API callbacks so your code can react when messages arrive, users join, channels are archived, or reactions change, and it surfaces the event payloads for downstream handling. The connector manages tokens and required scopes, handles rate-limit backoff and retries, and returns raw API responses and error codes so your app can decide when to retry or alert. It maps channel names to IDs, lists members, resolves user IDs and profiles, and supports uploading files with an initial_comment and visibility controls. For example, your CI pipeline can post build results and upload a log file, open a thread for triage, and tag the on-call channel automatically—so engineers see the failure and logs in Slack without copying links or switching tools, saving time and keeping debugging context in one place.

Build interfaces that actually stand out — this plugin steers Claude toward bold typography, striking color palettes, and distinctive layouts instead of cookie-cutter AI output.Create frontend designs that actually look like they came from a real designer, not a template generator. This plugin lets Claude build interfaces with intentional style—think bold typography choices, color palettes that pop, smooth animations that feel purposeful, and details that match what you're actually building. The result is polished, production-ready code that stands out from the typical AI-generated stuff.

Superpowers teaches Claude a disciplined, hands-on software workflow so it can behave like a developer on your team. It reads code snippets or repo context you give it, generates concrete unit and integration test cases, maps tests to implementation points, and outlines small TDD cycles: write a failing test, implement minimal code, run assertions, refactor. It frames commits and small diffs, and it drafts the commit message and PR description that match the test-driven changes. The plugin also walks through systematic debugging: it reproduces failure steps from logs or stack traces you paste, isolates likely root causes, ranks hypotheses, and suggests targeted fixes and smaller follow-up tests. It runs Socratic brainstorming sessions by asking constraining questions, proposing alternatives, and scoring trade-offs. For review-heavy flows it spins up subagent-driven reviews that check style, API contracts, and edge cases, then aggregates reviewer comments into a prioritized todo list. You can extend the framework by defining custom skills that read files, run a checklist, or produce a standardized review template. Use Superpowers when you want to go from failing test to merged PR without juggling docs, chat threads, or another review tool. For example, paste failing CI logs from a microservice, have Claude generate the failing test, propose a minimal patch, and collect subagent review comments — you avoid switching to a separate whiteboard session or manual inbox review and get a clear path to a green build. See the implementation on GitHub: https://github.com/obra/superpowers

Multiple specialized agents review your PRs and confidence-based filtering surfaces only the issues worth acting on — low-signal noise gets cut automatically.Get a fresh set of eyes on your pull requests without waiting for humans. Five specialized reviewers work through your code simultaneously, each focusing on something different—whether that's spotting potential bugs, checking your project guidelines, looking at git history for context, or finding missed comments. Everything gets a confidence score, so you only hear about the issues that really matter (by default, the really confident ones above 80%). It's like having a thoughtful code review team that never sleeps and doesn't clutter your PR with false alarms.

Stop pasting docs manually — this plugin pulls live, version-accurate documentation and real code samples directly from source repos into Claude's context on demand.Context7 brings fresh, up-to-date documentation right into your conversations—no more dealing with outdated APIs or code examples that don't work. It pulls live information directly from source repositories, so you get accurate, version-specific guidance instead of the hallucinated code and deprecated patterns that LLMs tend to default to. Think of it as keeping your AI assistant's knowledge current without having to manually search for the right documentation each time.

CLAUDE.md Management reads your project's CLAUDE.md, audits entries for relevance and duplicates, and marks stale or conflicting lines so you can focus on the parts that matter. It parses recent session logs and maps facts, decisions, and follow-ups back to the file format you already use. It also generates a short changelog of suggested edits and creates draft paragraphs you can accept or modify. It captures lessons from each interactive session by extracting concrete facts, commands run, file paths touched, and unresolved questions, then proposes where to append or replace content in CLAUDE.md. The tool checks for contradictions between memory entries and recent session evidence, highlights risky assumptions, and can create a compact summary of what changed across sessions. Use it when you finish a debugging sprint: the plugin pulls your session notes, summarizes the bug root cause and the commands that fixed it, updates CLAUDE.md with a clear "how we fixed it" section, and adds follow-ups to your task list. That saves you switching to a separate note app and prevents Claude from asking the same setup questions in the next code review.

Code Simplifier reads your files, applies targeted transforms, and writes back a cleaner version while keeping behavior intact. It parses functions and classes, renames confusing identifiers, extracts repeated logic into helpers, flattens nested conditionals, and replaces ad-hoc checks with clearer control flow. It runs local static checks and preserves test results so you can trust that changes are structural, not behavioral. When you edit code it watches for saved changes and offers an automated tidy pass you can run or schedule. It reformats to your project's style rules, consolidates duplicated code, removes dead branches, and collapses long expressions into named temporaries. You get a diff that highlights exact rewrites and can accept or revert each change in your editor or from a pull request. It integrates with linters and CI, and can run on a branch or in a pre-commit hook. Developers use it to make code easier to read, to reduce mental overhead during reviews, and to standardize patterns across a codebase without manual line-by-line edits. It logs the transformations it applied so reviewers understand the intent behind each change. Imagine opening a legacy feature branch with tangled conditionals before a code review: instead of switching between editor, formatter, and refactor tools you run Code Simplifier, get a focused set of edits, and push a single cleaner commit. That saves time and avoids juggling multiple tools during the review cycle.

Skill Creator helps you build Claude Code skills step by step. It presents a guided Create mode where you write skill code, define inputs and outputs, and attach example prompts. The tool reads your project files, scaffolds handlers, and generates a local dev environment so you can run the skill and inspect logs without manual setup. Eval mode runs test suites against your skill: it sends batches of prompts, records responses, and calculates concrete metrics like accuracy, response time, and failure rate. Improve mode applies targeted edits — you can generate new test cases, tweak prompt templates, or swap handlers, then re-run the same tests to compare results. The interface shows diffed outputs and highlights regressions. Benchmark mode runs A/B comparisons across versions and records historical performance. You can export CSVs of results, map metrics to releases, and set pass/fail gates for CI. The tool also packages a production-ready skill bundle you can publish or deploy. For example, a support team can use Skill Creator to build an FAQ skill, run dozens of real tickets through Eval, iterate prompts in Improve, and run a Benchmark to confirm the new version reduces incorrect answers — all without switching between editors, test runners, and spreadsheets.

Playwright MCP connects Claude to a real browser automation server so the assistant can open pages, follow links, click buttons, type into fields, select options, upload files, submit forms, and capture full-page or element screenshots. It exposes Playwright's navigation, waiting, and screenshot primitives through a simple control channel so you can script flows or ask Claude to interact with dynamic sites directly. Instead of relying on images, it reads the page's accessibility tree and DOM structure. That lets Claude locate elements by role, label, id, or XPath, wait for states like visible/attached/disabled, and extract text, attributes, and computed properties. It can run JavaScript in page context, evaluate selectors, and collect network and console logs for debugging. Authentication helpers handle cookies and localStorage; file download and upload are supported; and you can run end-to-end test suites or single-step interactions. Operations return structured results (status, node info, screenshot buffer, console messages) so callers can inspect outcomes and retry on failure. Use Playwright MCP when you want Claude to fill a multi-step checkout, grab data behind a login, or run a smoke test across pages without opening a separate test runner. It saves time by keeping navigation, DOM reads, and screenshots inside one tool instead of switching between browser devtools, test scripts, and manual inspection.

The official GitHub integration connects Claude Code to your GitHub account so you can manage repos without opening the web UI. You sign in with OAuth and grant repo scopes, then the plugin reads repository lists, pulls commit history, and shows branches and tags. It calls the GitHub REST and GraphQL APIs to fetch file contents, list PRs, and run repository searches. Use it to create and edit issues, add labels, assign people, and close or reopen items. It opens and reviews pull requests, posts comments, request changes, merge when checks pass, and fetches CI status. You can create releases, generate gists, trigger workflows, and apply small patches to files. It also runs custom API queries so you can pull stats, contributor graphs, or dependency info. From your terminal or editor you can jump between code, issues, and PR threads without switching apps. It reads diffs, maps comments to files, and writes back comments or reviews. It caches recent queries for quick lookup and respects repo permissions. In practice, use it when triaging a bug: open the failing PR, read the failing CI log, add a comment, create a follow-up issue, and assign it — all without leaving the editor. That saves context switching and keeps your workflow in one place.

Feature Dev guides a feature from idea to shipped code with a structured seven-step workflow and small focused agents for discovery, design decisions, implementation, and final review. It reads your feature brief or ticket, maps stakeholders and constraints, and generates a clear list of acceptance criteria and edge cases to validate against. During design it creates concrete artifacts: API sketches, data model diagrams, sequence steps, and a prioritized task breakdown. It generates user stories, example requests and responses, and a checklist of UX and accessibility points. For implementation it writes test templates, suggests coding tasks, and creates a ready-to-open pull request description. For review it runs a review agent that checks the checklist, compares changes to the acceptance criteria, and produces reviewer notes and a list of follow-up tasks. It can open issues, add labels, post PR comments, and produce a final release note draft so reviewers know what to verify. Imagine turning a vague product note into a ticket, design sketch, test plan, PR description, and release notes without leaving your editor or project board — you avoid hopping between docs, issue trackers, and review threads and cut handoffs and context switching during a sprint.

Claude Code Setup reads your repository, maps file types, and detects frameworks, package manifests, Dockerfiles, CI pipelines and common directory layouts. It runs static checks and dependency scans to figure out where automations can attach: server hooks, local subagents, skill entry points, MCP server roles, and slash command targets. It suggests specific code locations and generates concrete config snippets you can paste or commit: YAML for MCP servers, manifest files for skills, hook definitions, subagent templates and example slash-command handlers. It also lists npm/pip install commands, example env variables, and minimal runtime requirements. The tool shows change lists and patch-ready files so you can apply recommended files or copy them into your repo. It flags risky changes, points to relevant docs and gives sample tests you can run to verify the automation hooks. In a real-world scenario, a backend engineer can run it against a microservice repo, get ready-to-commit MCP and subagent files and a test plan, and enable CLAUDE CODE automations without juggling multiple docs, chat threads, or editor tabs — saving hours and avoiding context switching. GitHub: https://github.com/anthropics/claude-code

Commit Commands adds slash commands that run git actions from your chat or editor environment. It reads the repo, stages files you point at, generates a commit message based on your past commits, and runs git commit with the generated text or your edited message. You can run /commit, /amend, /stage, /unstage, and /status without switching to a terminal. It also runs git push and opens pull requests via the GitHub API. Use /push to push the current branch, and /pr to create a pull request with a title and body prefilled from your recent commit messages and branch name. You can pick target branch, add reviewers, and attach labels before the request is created. The plugin watches your commit history to match your message style and scope. It offers a preview you can edit, supports dry-run to show the exact git and API calls it will execute, and returns command output and links to the created PR so you can keep working where you are. In practice, while writing code and discussing changes in chat, you can stage, commit, push, and open a PR without switching to a terminal or the GitHub web UI—saving several context switches when you iterate small fixes or prepare multiple hotfix branches.

Ralph Loop runs Claude on a loop that reads its previous output, test results, and git history, then makes targeted edits on the next pass. It captures file diffs, commit messages, and failing tests so each iteration starts from the exact state of the last run. The plugin watches the repo, records state, and feeds concrete failure information back into the prompt so changes become focused and incremental instead of redoing work from scratch. On each cycle Ralph Loop runs the same test suite, parses failures, and applies edits or new commits. You can configure iteration limits, stop conditions, and which files to protect. The plugin stores every intermediate commit and exposes the chain of changes, so you can review why a particular fix was attempted and revert or cherry-pick any step. Ralph Loop connects to your local or remote git host, pushes commits, and preserves branch history. It annotates commits with the test output that triggered them and provides a clear loop log. You keep full control: approve or reject commits, force a different strategy, or inject a human note between passes. In practice this saves time when fixing flaky tests or iterating on a feature: instead of copying failures into a new tool and re-running builds manually, Ralph Loop keeps the context, runs tests, and updates code until tests pass or you stop it — no tool switching or lost debug state.

Connect Claude Code to your Figma files and pull design data into your editor. It reads pages, frames, layers, and component sets; extracts design tokens (colors, typography, spacing, radii); and returns a JSON representation you can inspect. The plugin maps auto-layout and constraints, so layouts and flow are preserved when you generate code or build components.Claude reads component instances and their overrides, then returns a component tree and CSS-like styles. It finds nested components, images, and vector paths, and it reports missing fonts or unsupported effects. You can ask Claude to generate React, Vue, SwiftUI fragments or plain CSS variables based on the tokens and component structure it pulled from Figma.It connects to your Figma account via a personal access token and can target specific file IDs or pages. The GitHub repo (https://github.com/tokens-studio/figma-plugin) contains the code for token extraction and mapping rules, which you can extend if your design system has custom properties or naming conventions.In a typical workflow, you open a design, point Claude at the file, and get ready-to-edit component code and a token set—no manual copy-paste of color values or re-measuring spacing. That saves time when converting a final Figma screen into components for a sprint, and avoids flipping between Figma and your IDE to reconcile tokens and layout details.

Adds TypeScript and JavaScript language intelligence to Claude Code: type-aware completions, go-to-definition, find-references, hover types, signature help, and real-time diagnostics. It reads your project's tsconfig, follows project references in monorepos, pulls type declarations from node_modules, and watches files so completion and errors reflect your workspace and compiler options. Provides refactor actions and quick fixes you can run inline: rename symbol across files, apply auto-import suggestions, organize imports, and run code actions that fix common type issues. Completions include semantic suggestions and auto-imports; hover shows inferred types and JSDoc. Diagnostics come from the TypeScript checker and include suggested edits you can apply with one click. The LSP integration answers go-to-definition and find-references requests, lists workspace symbols, maps references to exact ranges, and updates as you type. It supports JSX/TSX, resolves path aliases and module specifiers, and exposes signature help and code lenses where appropriate so you can operate without jumping to another tool. When you’re reviewing a PR or refactoring a shared utility in a monorepo, rename a function across packages, see where a type change breaks callers, and accept quick fixes without opening VS Code or running tsc in a terminal. That saves context switches and gets small edits merged faster.

Microsoft Docs pulls official Microsoft documentation into Claude Code on demand. It searches the full Microsoft Docs corpus — Azure, .NET, Windows, Microsoft 365 — and returns exact pages, API signatures, CLI commands, and code samples in readable markdown. It reads version and deprecation notes, maps related topics, and highlights the sections that match your query so you don't have to scan long pages. The plugin can filter samples by language, extract full code blocks, and convert examples into copy-paste-ready snippets. It checks source links and returns the canonical URL, so you can cite or open the original doc. It also looks up configuration options, REST specs, and SDK methods, then lists parameters and expected return types side-by-side. Use it when you need to fix a failing deployment, implement a specific API, or copy a tested sample into a code review: ask for the exact CLI command, the SDK call with parameters, and the minimal sample in your language, and get everything inline instead of switching to a browser, hunting pages, and copying fragments. GitHub: https://github.com/microsoft/power-platform-skills

Security Guidance is a real-time security co-pilot that reads your edits as you type and flags patterns like command injection, XSS, SQL injection, unsafe eval, insecure deserialization, and exposed secrets before changes are saved. It watches file edits in the editor, highlights the exact snippet that looks risky, and explains why the code is dangerous so you can decide how to fix it right away. The extension maps common risky APIs and patterns to concrete checks: unescaped template output, shell exec with user input, concatenated SQL strings, usage of eval/new Function, weak crypto choices, and unsafe third-party calls. When it finds an issue it records the file, line, and a short remediation — escape here, parameterize that, use a safer API — and it links to the GitHub repo for deeper rules and examples. It integrates with Claude Code so the assistant gets a heads-up when a proposed change would introduce a problem, and it can run on typing or on save. The tool also provides a quick scan mode for a whole file or project, and it can be tuned to ignore certain patterns or to require stricter checks for sensitive directories. For example, while editing an Express route that renders user input into HTML, the plugin will immediately flag unescaped output and suggest an escaping function — you fix it in-place without running a separate linter or opening a security scanner, saving time and avoiding tool switching during the normal edit-review cycle.

This plugin gives Claude real browser control so your agent can open a Chrome instance, inspect the DOM, set breakpoints, step through scripts, record performance traces, and capture network traffic. It talks to Chrome over the DevTools Protocol via Puppeteer, so the agent can run the same commands you'd type into the inspector. Use it to open pages, click elements, type into fields, read and modify attributes, take screenshots, capture HAR files, throttle CPU or network, emulate devices, and record a timeline trace. It can collect console logs, heap snapshots, and performance profiles, and it exposes the CDP domains you need to script audits, reproduce bugs, or validate rendering behavior. The agent can run repeatable tests: load a commit, run a user flow, capture traces and HARs, and store artifacts for comparison. It reads DOM state, checks resource timings, maps requests to stack traces, and records traces you can analyze without leaving your editor. For example, when a feature regresses in CI you can have the agent open the failing build, record a timeline trace and network HAR, and compare it to a prior run — you avoid switching to Chrome on your desktop and cut manual repro time during hotfixes.

This plugin connects Claude to ZoomInfo's B2B database and reads company and contact records so you can enrich leads without leaving your chat. It pulls firmographics, technographics, revenue and headcount ranges, titles and verified emails, and records the source and update timestamp for each match. You can search by company name, domain, SIC/NAICS, or custom filters and get a ranked list of prospects. It finds lookalike accounts by mapping your seed list to ZoomInfo attributes and runs similarity scoring to surface comparable companies. The tool generates AI-ranked prospect recommendations based on your CRM history and past outreach patterns, and it maps ZoomInfo fields to common CRM schemas so you can export or push matches back into your system. You can filter by location, intent signals, and recent funding activity, and it checks contact accuracy before returning results. Auth uses OAuth and the plugin respects your ZoomInfo API limits; it returns JSON-ready records you can program against or copy into CSV. It logs query parameters and lets you re-run searches with adjusted filters. You can preview contact lists, export batches, or send candidate lists to a specified CRM pipeline. Imagine a sales rep starting a call prep in Claude: they pull a company summary, enrich the key accounts on the fly, generate a ranked outreach list, and export contacts into the CRM without switching tabs — saving time and reducing manual copy-paste between ZoomInfo, a spreadsheet, and the CRM.

Remember records and organizes your Claude conversations across sessions. It reads your chat history and the files you touched, extracts key facts and decisions, and compresses them into tiered logs: short daily Haikus, medium summaries, and long-form context you can query later. It tags entries by project, file path, and topic so Claude can pull exactly the context relevant to the current task without re-reading everything.It runs automatically in the background with no setup: every time you work it appends new memories, updates summaries, and prunes redundant entries. Daily Haikus are short, human-readable snapshots that highlight what changed each day. Longer logs keep timelines, open questions, and code snippets so Claude can answer where you left off, what you decided, and why.Remember exposes commands to list recent memories, jump to a specific file’s timeline, and forget sensitive items. It compresses older content to save space and keeps recent context verbatim so debugging or design discussions remain actionable. You can query past decisions, search by tag, or ask for the chain of changes on a file.Imagine returning after a three-day break: instead of opening multiple repos and notes, Claude reads the project Haiku, pulls the file timeline, and reminds you which bug you were reproducing and which test you planned to write — saving you from switching to your task tracker or digging through commit logs.

This plugin connects your Claude Code environment to Vercel so you can trigger builds, list and inspect deployments, and stream runtime logs without opening the Vercel dashboard. It reads project settings, pulls domain and alias information, and shows build status and duration. You can trigger a new production or preview deployment, set or remove an alias, and view the deployment URL straight from your editor. It sends commands to Vercel's API to fetch environment variables, show build output as it happens, and display the last few log lines for any deployment. You can roll back to a previous deployment, cancel a running build, and check usage metrics like bandwidth or function invocations for a given deployment. It also maps domains and lets you check DNS verification status. Authentication uses your Vercel token so actions run under your account; the plugin shows which team and project you're operating on and warns when sensitive variables are exposed. It parses build errors and highlights failing steps so you can jump to the right file or commit. The UI returns URLs and deployment IDs you can copy into PRs or issue trackers. Imagine fixing a production issue: you pull recent logs, identify a failing serverless function, trigger a quick patch deploy, and if needed roll back to the previous deployment — all without switching windows. That flow saves context switches when you need to diagnose failures or update domains during a ticket-driven bugfix.

PR Review Toolkit runs six specialized agents on each pull request and returns focused findings you can act on. One agent checks that inline comments match the code behavior and flags stale or misleading notes. Another agent pulls test reports and verifies coverage for touched files, calling out uncovered branches and missing edge-case tests. A type agent scans type annotations and usage, points out inconsistent contracts, and suggests clearer types where bugs often hide. Other agents analyze error handling paths, map common exception flows, and highlight spots missing guards or retry logic. A code-quality agent enforces your style and architecture rules, lists violations, and shows exact lines to change. A readability agent scores complex functions, proposes smaller helper functions, and offers concrete rename suggestions to improve intent. The toolkit reads your CI artifacts, runs the checks in parallel, and writes a summarized report as PR comments and a checklist file in the branch. You can configure which agents run, set thresholds, and ignore files so the output matches your repo's priorities. In practice this saves time during reviews: instead of opening tests, coverage reports, and a typechecker in separate tabs, reviewers get a compact list of concrete fixes and failing checks right in the PR, so you avoid context switching and merge faster on high-velocity teams.

Pyright LSP brings Microsoft's Pyright type checker into Claude Code as a Language Server. It reads your workspace, watches Python files, and sends diagnostics and type information back to the editor. You get hover type previews, smart completions, go-to-definition, find references, rename, and workspace symbol queries powered by Pyright's analysis engine. It respects pyrightconfig.json, .pyi stub files, interpreter path and extra search paths, and it handles incremental checking across large code bases. The server reports precise errors (mismatched return types, incompatible assignments, missing imports), shows inferred types and generics, and flags unused imports and unreachable code. It also resolves types across installed packages and local modules so cross-file issues surface immediately. Use it while editing a Django app or a data pipeline: Pyright LSP highlights a wrong return type and points to every call site, lets you jump to the definition, and shows fixes without switching to another IDE. That saves time debugging type regressions and avoids opening a separate editor just for static checking.

Playground spins up single-file HTML sandboxes you can drop into a repo, share in a review, or open in a browser without installing anything. It builds a live preview pane that reloads as you edit, a set of visual controls you can bind to variables, and a prompt/output area that records the current state and copies it to clipboard with one click. The sandbox bundles CSS, JS, and assets into one standalone file so collaborators can open the same playground on any machine or environment. The tool lets you map controls to DOM properties, run custom scripts on change, and watch specific variables so you can inspect how interactions flow. It reads your HTML, injects the control UI, and runs the preview inside a safe iframe. It also logs events to a panel so you can trace how inputs affect state without leaving the page. Developers use Playground to prototype animations, debug interactive widgets, and collect reproducible steps for bug reports. In a client review, you can send a single file that the client opens locally; they tweak sliders, you watch the logs, and you copy the current prompt output to paste into a ticket — no rebuilding, no switching between editor and browser.

Full GitLab integration for Claude Code that reads and writes to your GitLab instance. It connects to projects, lists repositories, pulls branch and commit details, opens merge requests, posts comments, assigns reviewers, and merges when checks pass. It also reads pipeline status, triggers CI jobs, fetches job logs, and updates pipeline variables. The plugin reads issue lists, creates and edits issues, adds labels, moves issues between boards, and links commits or MRs to issues. It pulls wiki pages and writes updates, and it reads project and group settings so you can inspect permissions, members, and hooks without leaving your IDE-like environment. It authenticates with personal access tokens or OAuth, handles pagination for large projects, and maps GitLab concepts to Claude Code commands so you can script workflows. It fetches MR diffs, shows unresolved discussions, posts approvals, and can run quick code checks by downloading repository files. Imagine reviewing a merge request, running a failing CI job log check, posting a comment, and re-triggering the pipeline without tabbing to GitLab in your browser. That flow saves time during code reviews and bug triage when you need to switch context between terminal, browser, and chat tools.

QuickEnrich reads emails, domains, and names and sends enrichment requests to data providers. It returns structured JSON with person and company fields (name, title, company, location, tech, social). It supports single and batch lookups and runs retries with rate-limit handling so long jobs keep going. Configure provider API keys in settings, map incoming fields to provider params, and choose output format. It caches responses with timestamps so repeated lookups hit cache. The endpoint maps provider responses to a stable schema and offers CSV or JSON output for easy ingestion into pipelines or CRMs. For developers it logs requests and errors, exposes request IDs, and includes curl/postman snippets in the repo. It validates inputs, checks common mistakes (missing domain, malformed email), and returns clear error codes so callers can retry or skip bad rows. Scenario: a salesperson pastes 200 leads — QuickEnrich pulls firmographic and contact fields, maps them to CRM import columns, and generates a CSV ready to upload, so they avoid switching between enrichment dashboards, copying data, and manual spreadsheet cleanup. GitHub: https://github.com/laurigates/claude-plugins

Goes far beyond grep — uses language server semantics so Claude can understand code structure, trace references precisely, and suggest safe refactors.Serena turns Claude into a proper coding partner that actually understands your codebase. Instead of making you paste entire files, it can jump straight to the symbols and functions you need, then edit them intelligently. If you're working with Python, JavaScript, TypeScript, Java, Rust, Go, C++, or any of 30+ other languages, Serena uses Language Server Protocol to give Claude real symbol-level awareness—like having an IDE built into your chat.

Install and run Terraform commands from Claude Code: init, fmt, validate, plan, apply, destroy, import, taint, output and state. It talks to a Terraform MCP Server that runs terraform binaries, reads your HCL files and module folders, and returns plan JSON, stdout/stderr and exit codes. You can request a human-readable plan diff, ask for the resources affected, or fetch remote state and resource attributes without leaving your editor. The plugin reads workspace and backend settings, accepts environment variables and var files, and runs targeted applies or refreshes. It can upload or download state snapshots, run show on a plan file, and parse plan details into resources to add comments or approvals. It also checks for formatting and validation errors and can run terraform fmt / validate as part of a pre-commit check you trigger from Claude Code. Use it to generate a concise change summary, fetch outputs for downstream scripts, or run a safe plan then produce an approved apply command. It shows plan diffs and resource counts so reviewers see exactly what changes will occur. Example: instead of switching to a shell to run terraform plan, open the module in Claude Code, ask for a plan and a list of tainted resources, then request apply after an approval—saving context switches when reviewing and applying PR-linked infrastructure changes.

Sales teams, growth operators, and RevOps professionals spend a staggering amount of time bouncing between tools — a CRM here, a data provider there, a browser tab for company research somewhere else. The Lead411 Claude Plugin changes that by bringing Lead411's B2B contact and company intelligence directly into Claude, so your entire prospecting workflow lives in one conversation. What It Does The plugin connects Claude Code and Cowork to Lead411's MCP (Model Context Protocol) server, giving you a set of powerful slash commands that turn natural language into real sales intelligence: /lead411:search — Find contacts by title, industry, location, tech stack, or hiring signals. Ask for "VP of Sales at SaaS companies using Salesforce in California" and get a targeted shortlist back instantly. /lead411:get-company — Pull a full company profile including firmographics, tech stack, recent news, and open roles. Great for account research before outreach. /lead411:get-employee — Get an enriched profile on a specific person, including their role, seniority, and contact availability. /lead411:unlock — Reveal gated contact details like direct email and phone numbers. It always shows a credit confirmation before consuming anything, so there are no surprises. /lead411:push-to-crm — Sync contacts and companies directly to Salesforce, HubSpot, Pipedrive, and other supported CRMs without leaving the conversation. /lead411:enrich — Paste a list of domains or upload a CSV and batch-enrich an entire company list in one shot. /lead411:configure-crm — Check your CRM connection status and walk through setup if nothing is connected yet.

LegalZoom reads contracts and other legal documents you upload, scans for common risk areas, and returns an annotated summary in plain language. It highlights problematic clauses, missing standard protections, and unusual terms, then maps each issue to a RED/YELLOW/GREEN risk level so you know what needs urgent attention versus what is likely safe. The plugin also extracts key metadata — parties, dates, payment terms, renewal windows — so you can compare versions quickly. It generates short explanations for flagged items, suggests negotiation language you can paste into an email, and links each point to relevant law sections or plain-English guides so you can verify the reasoning. When a flagged item requires a licensed attorney, the plugin connects you directly to LegalZoom's network of real lawyers and can open a consult request with the document attached. Developed for people who sign many agreements, it supports PDFs and common text formats, tracks what it reviewed, and keeps a simple history of past scans for reference. The tool reads your inputs locally in the session and returns structured findings you can copy or export. Example: a freelancer receives a long client contract with a problematic indemnity and tight deadlines — LegalZoom flags the indemnity as RED, suggests safer wording, and offers a lawyer consult without switching apps. That saves the back-and-forth of exporting files, drafting notes, and hunting for an attorney before you hit “sign.”

Adds Ruby language server support to Claude Code so you get IDE-style features inside the editor. It reads your .rb, .rake, .gemspec, .ru, and .erb files, runs Shopify’s Ruby LSP under the hood, and exposes hover docs, go-to-definition, find references, and symbol search. The server parses gems and Rails code, maps method locations, and returns precise types and signatures for completions and inline documentation. It watches files and sends diagnostics as you type, flags runtime errors and type mismatches, and runs automatic formatting and safe renames across the workspace. The extension generates intelligent completions based on project context, checks for unused variables and missing requires, and records code actions like quick fixes and imports. You can configure lint rules, enable/disable features, and point the server at your project’s RUBY_VERSION and gemset. Imagine editing a Rails model, renaming an attribute and seeing the rename applied across models, controllers, and views without opening a separate IDE. Or catching a nil-safe call flagged by the server while working in a view file, jumping to the method definition, and applying a suggested fix — all without switching tools or running the full test suite, which saves time during tight bugfix cycles.

The Discord plugin connects your Claude Code environment to Discord servers using a bot token or OAuth. It reads channel lists and member lists, pulls message history, sends and edits messages, posts files and images, and adds or removes reactions. It checks channel permissions, creates or archives channels and threads, and maps Discord roles to user IDs so you can target messages or queries to the right group. It watches channels and threads for new messages, returns structured message objects, and supports attachments and embeds. You can run commands that fetch user presence, list pinned messages, delete messages by ID, and create webhooks that send messages without the bot account. It also records timestamps and message IDs so you can reference or update specific posts later. Use it when you want to pull discussion context into code, send reports to a channel, compile recent bug reports, or post build artifacts without switching to the Discord app. For example, generate a test report in Claude Code and have the plugin post the report file and a summary to a dedicated channel, saving manual copy/paste and avoiding context switching between tools.

Apollo connects to the Apollo.io API and wires several endpoints into three ready-made skills that run full sales tasks end-to-end. One skill reads a name or email and pulls enriched contact and company data, including titles, locations, technologies, recent signals, and social links. Another accepts plain-language buyer descriptions, runs a profile search, ranks matches by fit and intent signals, and returns paginated prospect lists. The third locates contacts and loads them directly into an outreach sequence with assigned cadence, step content, and send windows. The skills handle API paging, deduplicate by email, map fields to common CRM shapes, and surface confidence scores and source tags so you can filter results before you act. You get JSON-friendly outputs that your code can parse, or formatted CSV ready for upload. Calls include enrichment, role filters, company size and tech-stack constraints, and optional recent-activity filters. Authentication uses standard Apollo API keys; the plugin logs request status and returns error details when a lookup fails. You can call a search skill, inspect ranked prospects, then call the sequence skill to add only the winners — all programmatically without manual data shuffling. For an SDR team preparing a campaign, Apollo saves time by letting a script read a target profile, pull ranked prospects, enrich contacts, and queue them into a sequence without switching between Apollo’s web UI, spreadsheets, and the CRM. That keeps you in a single flow for list building, enrichment, and launch.

Uses Common Room's buyer signal data to power account research and personalized outreach — Claude becomes your GTM teammate with full visibility into what prospects are doing.Turn Common Room into your GTM copilot that actually knows what's going on with your accounts. Research prospects, get ready for calls with real attendee profiles and talking points, and write personalized emails, LinkedIn messages, and call scripts in minutes. Build prospect lists, create weekly call briefings, and develop account strategies — all based on real data from how people are actually using your product.

A comprehensive guide and toolkit for building your own MCP servers — covering tool design, auth patterns, and all three deployment modes.Building an MCP server to work with Claude doesn't have to be complicated. This guide walks you through the whole journey — deciding how to deploy it, designing your tools the right way, and getting your code up and running. You'll learn how to add authentication so everything stays secure, package everything for distribution, and choose between remote HTTP servers, interactive apps with built-in UI, or local bundles depending on what you need.

Explore your warehouse, inspect tables, and sample rows without leaving the editor. The extension connects to Snowflake, BigQuery, Redshift, and Postgres instances, pulls schemas, reads column statistics, and runs profiling queries so you can spot skews, nulls, and cardinality issues. It generates ready-to-run SQL snippets, maps schema changes to downstream models, and records table lineage as you edit transformations. This plugin exposes over 30 focused skills and an MCP server that talks to Apache Airflow's full REST API. You can create and edit DAGs, push DAG files, trigger runs, check task status, read task logs, clear failed tasks, and watch scheduler health. It edits dbt models, runs dbt commands, writes tests, and commits changes with clear git messages. The tool also helps write pipeline code: it scaffolds Python or SQL transformation functions, generates parametrized operators, and creates sensible defaults for retries, timeouts, and task dependencies. It tracks schema drift by comparing current table metadata to expected models and flags breaking changes so you can add tests or migrations. Imagine fixing a failing Airflow task: you inspect the table samples, write a quick SQL patch, update the DAG, push the change, and trigger a backfill — all from the same interface. That avoids context-switching between console, SQL editor, git, and Airflow UI, saving hours when debugging production pipelines or shipping hotfixes.

Connect Claude Cowork to Slack to read messages, search channels, and draft replies without leaving your coding or documentation workspace. The integration pulls channel lists, thread messages, and file links; it maps user mentions and reactions so you can filter by people or by activity. It reads pinned items and thread replies, and it marks which messages are unread so you only surface new context. Use the connection to generate meeting summaries from threads, create status updates from channel history, and draft message threads or announcements ready to post. It sends drafts back to Slack as messages or scheduled posts, and it records which draft was posted. You can ask for highlights from a channel, check who answered a question, or pull links to relevant files and messages. Imagine closing a sprint planning doc and then asking Claude to pull last week’s #dev standup notes, generate a release announcement, and post it to #releases — all without switching apps. That flow saves time by keeping reading, writing, and posting in one place, so you don’t jump between Slack and your editor during tight deadlines.

Clangd LSP adds the LLVM/Clang language server to Claude Code so you get precise C and C++ editing features inside the editor. It reads your project compile_commands.json or compile flags, builds an index across files, and provides on-the-fly diagnostics, semantic highlighting, and accurate code completions for .c, .h, .cpp, .cc, .cxx, .hpp, and .hxx files. It also runs formatters and applies code actions such as include fixes and quick refactors. The server answers go-to-definition, find-references, and symbol-search requests across translation units, so you can jump from a declaration to the implementation or track where a function is used. It watches file changes, keeps the index up to date, and returns diagnostics with precise locations. It also respects header search paths and preprocessor macros from your build configuration so suggestions match real build behavior. For a concrete workflow: open a mixed C/C++ codebase, let clangd read compile_commands.json, then fix an error shown by the diagnostic, jump to the header that defines the type, and apply the include-fixer code action without leaving Claude Code. That avoids switching to a separate IDE to debug missing includes or hunt references across files, saving minutes per bugfix and keeping you focused in one tool.

Powered by Intelephense, PHP LSP adds rich PHP code intelligence to Claude Code. It reads your project files and builds a symbol index so it can generate context-aware completions, show function and method signatures as you type, and infer basic types across files. The server watches for file changes and updates diagnostics in real time, so you see unused variables, undefined methods, and probable type mismatches without running tests. It offers navigation primitives developers expect: jump to definition, find all references, and search symbols across the workspace. The extension checks docblocks and PHP 7+/8+ type hints, resolves namespaces and use statements, and reports common runtime issues. Completions include properties, methods, class names, and imported functions based on the current scope. Configuration options let you tune indexing depth, exclude folders, and set memory limits for large repositories. The plugin connects Claude Code to Intelephense’s diagnostics and keeps responses fast by caching parsed ASTs and reusing them between edits. Use it when you're refactoring a Laravel or Symfony app: the plugin finds all references to a model or service, shows where types diverge, and lets you jump between controllers, models, and views without switching to an external IDE — saving time and context switches during a sprint.

Laravel Boost adds deep Laravel knowledge to your editor workflow. It reads your composer.json, routes, models, migrations and policies so suggestions match your app's namespace, model casts, and existing relationships. It parses controllers and form requests to propose parameter types, validation rules, and route bindings that follow your conventions. It also maps database columns to factory definitions and seeds when you ask for test data. The plugin hooks into Artisan so you can run make:controller, make:migration, make:policy or custom commands from the assistant and get inline diffs or ready-to-run artisan calls. It generates Eloquent queries, joins, scopes and eager loads based on your models and relationships. When you request a new route, it suggests route names, middleware groups, and the exact route definition to paste or apply. It reads your tests and factories to suggest realistic test cases and data. It writes migration boilerplate, policy methods, controller actions, request validation, and resource responses with concrete code snippets. It checks for breaking changes against your current code and points out places where you’ll need to update type hints or imports. Imagine adding a new resource with controllers, requests, tests and a migration: instead of switching between docs, terminal and editor, Boost reads your app, generates the artisan commands and code patches, and shows filename diffs so you can accept changes without jumping tools — saving setup time and avoiding copy-paste errors.

Connects Claude Code to iMessage on your Mac by reading the Messages SQLite database (chat.db) and sending messages through AppleScript-driven Messages.app. It opens chat.db rows and pulls conversation text, sender IDs, thread identifiers and timestamps so Claude can read full threads and draft context-aware replies. Everything runs locally on your Mac and uses your Messages.app so there are no external servers, API tokens, or cloud copies required. You control who Claude can talk to: set an allowlist of phone numbers or Apple IDs, require a short-lived numeric pairing code for one-time approvals, and revoke pairings at any time. The plugin watches chat.db for new messages, maps metadata to events, checks macOS permissions before reading or sending, and records pairing and audit events locally. Outbound messages are sent with AppleScript calls to Messages.app, so delivery and attachments follow your normal Messages behavior. Useful when you want Claude to draft or send replies without switching apps — for example monitor a shared support number, draft standard responses, and send confirmations after a quick review. By keeping data and controls on your Mac and using allowlists and pairing codes, you save time and avoid hopping between web tools, the Messages app, and a separate automation console. Source: https://github.com/anthropics/claude-plugins-official

Plugin Developer Toolkit bundles seven focused skills that show how Claude Code plugins are built from the ground up. It reads and explains hook lifecycle, maps plugin manifest structure, shows MCP server registration and auth flows, and demonstrates how slash commands and agent entry points work. The repo includes over a dozen runnable examples so you can open code, run it, and see requests and responses in context.You get six validation scripts that check manifests, type schemas, and security headers, plus more than 21,000 words of documentation that walks through deployment patterns, error handling, and testing strategies. The package sends ready-to-run dev server configs, example webhooks, and test payloads so you can iterate locally. It also shows how to author new skills and wire them into agent and slash-command flows.Imagine building a support bot that needs slash commands, background hooks, and an MCP server for auth: the Toolkit provides examples, validation checks, and deploy configs so you can code, test, and deploy without switching between scattered guides and repos. The GitHub repo at https://github.com/anthropics/claude-code stores all examples and scripts for cloning and immediate use.

Integrates Apple's SourceKit-LSP to bring SourceKit features into Claude Code for Swift and mixed Swift/Objective-C projects. It connects to your workspace, reads compile flags and package manifests, and starts a language server that speaks the project's build settings so completions and diagnostics match what the compiler sees. It provides context-aware completions, parameter help, signature information, and semantic highlighting. You can jump to definitions, find references, get workspace symbols, and apply code actions like fix-its and organize imports. Diagnostics update as you edit and point to the exact file and line the compiler would report. The extension watches file changes, indexes modules and packages in the background, and responds to textDocument/hover, textDocument/rename and workspace/symbol requests. It reads Package.swift, Xcode build settings, and SwiftPM layouts so navigation and type-aware suggestions work across targets and test bundles. For example, when you work on an iOS app with several frameworks and bridging headers, you won't need to open Xcode to check where a type is defined or whether a new change breaks compilation; the server pulls the right flags and shows diagnostics inside Claude Code, saving context switches and time.

Postman brings the full Postman platform into Claude Code. It connects your Postman account via the MCP Server, syncs collections and environments, and pulls up API schemas and examples. You can browse and import collections, watch for collection updates, and map requests to local files so your code references stay in sync without flipping back to the Postman app. You can generate client code and code snippets in multiple languages from collection requests, export SDKs, and create ready-to-run examples for teammates. The plugin runs collection and integration tests, reports failures with request/response logs, and starts mock servers from examples. It also publishes API documentation and runs security checks against your workspace to flag common misconfigurations or missing auth flows. Use it when you’re coding in Claude Code and need to run a Postman test, generate a TypeScript client, or spin up a mock server without opening a browser. For example, when a backend change breaks an endpoint, you can pull the latest collection, run failing tests, inspect responses, generate a patched client, and push documentation updates — all from the editor, saving context switches and time.

Hook up Claude Code to Hugging Face so you can load models and datasets, inspect weights, pull model card metadata, and spawn Spaces without leaving your editor. You can call endpoints, switch a model to inference mode, or download checkpoints. The interface exposes dataset tables and sample rows so you can preview examples and schema before you commit to training. Use the TRL stack on cloud GPUs to train and fine-tune language and RLHF-style models: start jobs, watch logs, cancel runs, and download checkpoints. Create and manage datasets from SQL queries, run preprocessing steps, and map tokenization across splits. You can run evaluation scripts, collect metrics, and compare runs side-by-side. Track experiments by recording hyperparameters, artifacts, and metrics, then pull past runs for analysis. Publish a Space, push model cards, or upload datasets and metadata to Hugging Face from Claude Code. The tool reads error traces and suggests next steps so you can iterate faster. In practice you can run a quick fine-tune, evaluate against a test suite, and deploy the best model to a Space without switching browser tabs — useful when you need to ship a bugfix model for content moderation or prototype an NLU update during a sprint.

This plugin adds gopls, the official Go language server, into Claude Code so your editor reads packages, symbols, and types the same way the Go toolchain does. gopls parses go.mod, watches package files, and provides type-aware completions, signature help, and inline diagnostics that match go build and go vet. It runs in the background and talks to Claude Code over the Language Server Protocol. It reads your workspace and returns precise "go to definition", "find references", and symbol search results across modules and vendor folders. The plugin sends code actions for common fixes, runs renames and safe refactors that update imports and call sites, and applies workspace edits atomically. It also reports unused imports and unreachable code so you see the same errors you'd get on CI. On edits it watches file changes and recomputes diagnostics and completions incrementally, keeping responses fast even in large repositories. You can request hover type info, expand/contract selections based on AST nodes, and get quick fixes like adding missing imports or applying suggested type conversions. It supports module-aware workspaces and respects build tags and GOFLAGS. For example, when splitting a large package or renaming a core struct, gopls runs the rename across files, updates imports, and shows diagnostics inline so you avoid bouncing between an editor, go list, and separate refactor tools. That saves time on large code moves and keeps you in Claude Code instead of switching to a dedicated IDE for precise Go refactors.

Bridge your Claude Code environment to your Telegram account with secure pairing and allowlist controls. The plugin opens a pairing flow that reads a QR code or pairing token, stores a scoped session, and maps Telegram chats and users to local identifiers. It reads incoming messages, downloads media attachments, and writes outgoing messages and files back to the mapped chat. You can enable or disable specific chat IDs on the allowlist so only approved conversations pass through. From the terminal you can run commands that pull message history, search by keyword, and stream new messages as they arrive. The plugin records delivered message IDs and timestamps, marks messages as read, and exposes metadata like sender name, chat type, and link previews. It supports group and private chats, handles forwarded messages, and preserves attachment MIME types when saving files to disk. Use the plugin to send quick replies, batch-send notifications, or archive chat logs without opening the Telegram app. It keeps pairing tokens local and offers a revoke flow to drop sessions. For example, a support engineer can run a single terminal script to gather the last 24 hours of customer chats, download attached logs, and post an operator note back to the same chat — avoiding switching to the Telegram app and saving tens of minutes per incident.

Hook into your git workflow and get a risk score before you commit. The tool reads your pending diff, calls the PagerDuty API to pull incident records for the last 90 days, and maps incident metadata to the files and services your diff touches. It parses incident summaries, deduplicates by service and file path, and produces a numeric risk score plus a short breakdown: which files are linked to recent outages, how many incidents, when the last incident occurred, and whether any incidents are still marked active or unresolved. The plugin runs locally as a pre-commit or pre-push check, authenticates with your PagerDuty account, and caches recent incident data for speed. It flags high-risk hunks inline with your diff and outputs a concise report you can read in CI logs or your terminal. It also offers a JSON output you can pipe into other tools and a threshold you can fail builds on if the risk score exceeds your policy. Imagine fixing a config change that touches an auth module and seeing an immediate alert: three incidents in the last 30 days tied to that module, last incident still open — abort the commit and open a patch request instead. That saves you from toggling between the terminal, the PagerDuty site, and your repo UI to cross-check history, and it prevents deployments that would trigger on-call pages.

Brings SonarQube's code quality and security scanning directly into Claude Code through slash commands and guided workflows. Analyze code for vulnerabilities, bugs, and code smells without leaving your IDE, streamlining quality assurance and compliance checks.

Hookify connects your Claude Code projects with GitHub webhooks and local endpoints so you can route events into model-driven workflows. It reads webhook payloads, validates signatures, maps event types to handlers, and forwards JSON to configured Claude Code routes. You can add retry rules, filter by branch or file paths, and log incoming events to a local file or remote sink. Installation instructions and source are on GitHub: https://github.com/anthropics/claude-code. The tool runs as a small HTTP service, watches a config file for changes, and exposes a simple UI endpoint that lists recent events and delivery status. It supports HMAC secrets, custom headers, and TLS for public endpoints. Operational features include a test event sender, delivery retries with backoff, and a plugin script hook that transforms payloads before forwarding. The service records request/response pairs, checks for common webhook errors, and can mute noisy event types so your Claude Code routes only receive relevant data. Use Hookify when you want incoming GitHub activity to trigger model flows without opening cloud portals. For example, it receives PR comments locally, filters for “/rerun” commands, transforms the payload, and sends a compact request to a Claude Code route — saving time and avoiding manual copy-paste between GitHub and your development tools.

Sourcegraph connects your Claude Code workspace to enterprise-scale code search so you can read and navigate millions of lines without hopping between browser tabs. It queries your Sourcegraph instance, pulls repository indexes, and runs semantic or pattern-based searches (keyword, regex, or commit history) from the same interface where you write code. You can jump to symbols, open file locations, and map call graphs as plain links or code snippets. It traces references across repos and computes refactor blast radius: run a symbol search, list all references, and then check each reference’s file and commit context. You can run security sweeps by searching for vulnerable function names, authentication flows, or unsafe patterns and then record the matches with file paths and line ranges. The plugin also supports Deep Search queries to find similar code by intent, not just text. When you need details it fetches file contents, shows surrounding lines, and returns commit metadata so you can see who changed what and when. It formats results as clickable navigation links or pasted code snippets you can edit locally. You can combine searches, filter by branch, and request diffs or blame info directly from Claude Code. For example, when preparing a cross-repo refactor you can list all uses of a public API, inspect each implementation, and generate a remediation checklist without opening Sourcegraph in another window. That saves time and avoids switching tools during review and edits.

Brings LSEG's institutional market data into Claude — price data, analytics, and deal intelligence for building financial models and drafting research at a professional standard.Financial professionals can pull live market data and analytics directly into Claude conversations—think real-time yield curves for DCF models, current pricing across assets for portfolio rebalancing, and actual financing data for deal analysis. It's like having LSEG's institutional-grade content woven right into your workflow, so you can draft morning notes with fresh news or build analyses without switching between tools.

Greptile connects to GitHub and local git checkouts, reads source files, and builds a searchable index of code, comments, and filenames. It pulls repo metadata, watches commits on branches, and updates the index when new commits arrive. You can restrict searches by language, path, file extension, or commit range, and it records the commit hash and file path for every match so you can jump straight to the exact version that contained the text. It runs regex and token searches across large codebases and returns matches with surrounding context and hits-per-file counts. The plugin maps symbol definitions to their references by scanning import and include lines, so a single query can return both a function definition and the files that call it. It supports previews and opens the file at the right line in your browser or IDE when you want to inspect or edit. Searches can be saved as named queries, scheduled to run on a branch, and shared with teammates via a short URL. Greptile also exports match lists as CSV or JSON and can filter results by author, date range, or commit message content. It records provenance so you can see when a match was added or removed and who pushed the change. Use it during a migration or API change: run a single saved query to find every use of an old API across dozens of repos, open the exact lines in the right commit, and export the file list to assign fixes — no flipping between GitHub search, local clones, and spreadsheets. That saves time and reduces context switching when you need a reliable, repo-wide list of code locations to update.

Data connects Claude Code to your databases and CSVs and helps you explore tables, sample rows, and schema. It reads data sources, inspects column types, and lists foreign keys and indexes so you quickly understand structure before you write queries. It writes SQL queries you can run against PostgreSQL, MySQL, SQLite, and common cloud warehouses, and adjusts syntax across dialects. It can generate JOINs, aggregations, window functions, and parameterized queries, and it explains why a query returns certain rows. It generates charts and dashboards from query results: line, bar, scatter, histogram, and pivot tables. It maps columns to axes, sets labels and colors, and exports PNG or interactive embeds. You can iterate on visualizations without exporting CSVs or hand-editing code. In a real workflow, you can ask for a retention curve, get the SQL, run it, tweak the chart, and save a dashboard — all inside Claude Code. That avoids switching to a separate BI tool just to explore a table, build a chart, and share a result with teammates.

Connect your dev workflow to Atlassian tools and keep working where you already are. Create, update, comment on, transition, and attach files to Jira issues; run JQL and pull lists or single-ticket details; search Confluence pages, fetch page content or page history; and read Compass components and service metadata. It uses OAuth, so it reads and acts with your existing Atlassian permissions instead of bypassing access controls. Use plain language to generate tickets, map labels, and assign owners, or ask for a JQL query and get back structured results you can copy into scripts. Pull Confluence sections into a status report, export ticket lists to CSV, and run bulk updates or scripted transitions. You can also add comments and watchers, create sprint reports, and snapshot backlog views without switching tabs. Imagine preparing a release status: pull the sprint backlog, list blockers by label across projects, fetch the latest Confluence release notes, and create follow-up Jira tasks from a single chat thread. That workflow removes manual copying, reduces tool switching, and saves time during tight ship cycles.

Connect Claude directly to MongoDB databases to query collections, analyze data, and manage database operations through natural language. This MCP server plugin enables seamless exploration of your MongoDB data and automated database tasks within your coding workflow.

This plugin turns Claude into a live web data tool: it reads pages, follows links, fills forms, clicks through paginated lists, and extracts structured fields, tables, images and metadata. It returns results as JSON, CSV or records you can query later. It runs single-page scrapes and multi-step agents. You can map selectors, apply regex, run JavaScript to render dynamic sites, and handle rate limits and retries. Built-in connectors cover 50+ popular sites so you can start by editing an existing agent instead of building from scratch. Agents can run on a schedule, store outputs in a datastore, and call back into Claude to validate or summarize results. You get logging, error alerts, and retry policies so long crawls keep running without manual babysitting. Imagine monitoring competitor prices across dozens of product pages: the agent reads each site, pulls price and availability into a CSV, and emails a daily digest — no manual browser clicks, separate scraper app, or cron job to maintain.

End-to-end serverless development on AWS — design functions, wire up services, deploy, and debug without leaving Claude Code.Build and deploy serverless applications on AWS without leaving your editor. This plugin gives Claude the knowledge to work with Lambda, API Gateway, EventBridge, and Step Functions, plus it connects directly to your AWS resources so you can manage them in real time. You can scaffold new projects with SAM CLI or CDK, design event-driven architectures, handle deployments across multiple environments, and set up CI/CD pipelines—all with AI assistance guiding you through each step.

Open Sentry error data right where you code. Authenticate with your Sentry API token and the plugin reads issue lists, recent events, and full stack traces from the projects you select. It pulls severity, environment, release, event timestamps, user impact counts, tags, and breadcrumbs so you can see the exact call path that led to an error without opening a browser tab. Ask natural language questions to find related issues, filter by tag or release, or show all regressions in the last 24 hours. The plugin maps frames in stack traces to source files and shows suspect commits and release links. You can jump straight to the Sentry event, open the issue view, or copy a permalink to paste in a PR or chat. The tool highlights trending errors, groups by fingerprint, and shows sampling rates and error frequency graphs inline. It also exposes affected user counts and environments so you can prioritize fixes and decide whether to roll back a release or patch a handler. For example, when a monitoring alert fires at 2 AM you can pull the top new errors, read stack traces, and open the implicated source files in your editor all in one place—no context switching between Slack, Sentry, and your codebase. That saves time when triaging incidents and writing urgent fixes. GitHub: https://github.com/getsentry/sentry-for-ai

Lua LSP integrates the Lua Language Server into Claude Code so your editor reads project files and provides language-aware tooling for Lua 5.1–5.5 and LuaJIT. It opens workspace folders, indexes source and library paths, and watches for file changes to keep symbols and diagnostics current. The server returns completions, hover documentation, signature help, and parameter hints while you type. The extension also runs diagnostics and type checks, reports undefined globals, unused locals, and likely runtime errors before you run code. It handles go-to-definition, find-references, workspace symbols, rename refactors, code actions, and formatting. You can map runtime paths, set workspace globals, and tune diagnostic severity to match frameworks like LÖVE or embedded Lua builds. Use it when editing game scripts or embedded device code: you stay in Claude Code to jump to function definitions, rename across files, and fix diagnostics without switching to another editor or running the app to discover a misspelled global. That saves time during large refactors and speeds up finding where an API is actually defined.

Turns any website into clean structured data Claude can reason over — scrape individual pages, crawl entire sites, or run an autonomous agent to gather exactly what you need.Firecrawl transforms websites into clean markdown or structured data that's ready for AI to work with. It handles everything from scraping individual pages to crawling entire sites, automatically rendering JavaScript, bypassing anti-bot protections, and rotating proxies so you don't have to worry about the technical headaches. Whether you need to extract content from a single page, map out a whole site's structure, or search the web, it's all built right into Claude Code.

Connect Claude directly to your Supabase backend and run SQL, manage auth rules, configure storage buckets, inspect real-time subscriptions, and read project logs without opening the dashboard. You can run queries, list tables, inspect schemas, and apply migrations from the conversation. The integration exposes over 20 tools that map to common supabase-cli and dashboard actions so you can keep working in one place. It reads and writes database rows, creates and deletes storage objects, sets and revokes role policies, and updates environment variables. You can create or rollback migrations, generate REST endpoints, check replication status, and pull usage metrics. The plugin watches realtime channels and reports emitted events so you can debug live behavior. Use it to inspect auth flows, validate RLS policies against sample requests, and tail function logs. It shows query plans, returns execution errors, and lets you restart services or trigger backups. One sentence: this plugin sends commands to your Supabase project and returns structured responses you can act on. For example, during a production incident you can run a failing query, read the realtime event stream for a user, patch an RLS policy, and restart a function without opening the dashboard or switching windows—so you finish triage faster and avoid context switching between tools.

This plugin runs SAST analysis and secrets detection as you write, catching hardcoded credentials and infrastructure misconfigurations before they ship. It watches file edits and incremental saves, parses source files and config files, and flags risky code patterns inline. It supports JavaScript, TypeScript, Python, Go, Java, Dockerfiles, Terraform and Kubernetes YAML. Aikido Security detects leaked API keys, AWS/Azure/GCP credentials, private SSH keys, and common insecure patterns like SQL concatenation or unsafe deserialization. It annotates the exact lines, explains the issue, maps to CWE where applicable, and generates suggested code fixes or quick patch diffs you can apply. It also offers ignore comments and configurable rules so teams can tune noise. The integration exposes results in your editor and in pre-commit flows, and connects to your repo for context-aware checks so findings include file history and recent commits. It runs fast incremental scans so you get feedback before you hit commit or open a pull request, and it links to the GitHub repo for rule details and contributions. In a real scenario, a developer typing a Terraform change sees an inline alert for a publicly exposed S3 ACL and a detected hardcoded AWS key, accepts the suggested patch to replace the key with a reference to a managed secret, and avoids switching to a separate scanner UI or delaying a PR to fix issues later.

PlanetScale gives Claude live, authenticated access to your PlanetScale accounts so you can browse organizations, databases, and branches without leaving your editor or chat. You can list branches, inspect branch status, and fetch connection details. It maps your schema objects—tables, columns, indexes—so you can ask specific questions about structure and relationships. Run SQL queries against a selected branch and return results as JSON or tabular text. The plugin reads query execution info and pulls Insights metrics so you can check slow queries, error rates, and query distribution. It also exposes account and organization metadata so you can verify permissions and billing context while debugging. The tool supports interactive workflows: run a query, review results, then request a follow-up optimization that references exact slow queries from Insights. It lets you switch branches, re-run tests, and compare schemas across branches without copying connection strings or hopping into a separate console. For example, when a staging endpoint shows errors you can inspect the failing query, pull the Insight that highlights its latency, and try an optimized query all inside Claude. That saves time and prevents context switching between your chat, a SQL client, and the PlanetScale console during an incident response or schema review.

Sonatype Guide connects Claude Code to Sonatype's intelligence so your editor can scan project dependencies for known supply-chain risk. It reads manifests and lockfiles (package.json, pom.xml, go.mod, etc.), pulls vulnerability and policy data, and highlights packages with known CVEs, problematic licenses, or low quality scores. It shows the vulnerable version, the vulnerability ID, and the risk score so you can decide what to change. From inside the editor you can run a full dependency scan or a quick check on a single file. The plugin recommends safer versions, lists the delta between your version and a suggested upgrade, and maps transitive dependency chains so you see the true source of risk. It also checks licensing flags and quality indicators so you can assess non-security issues before they hit production. Scan results include actionable items: package names, vulnerable ranges, suggested fixes, and links to the Sonatype intelligence entry for each issue. You can copy a suggested version bump, open the advisory page, or record findings to your issue tracker. The plugin keeps results local to your workspace and updates as you edit files so you get immediate feedback while you code. In a real project you can run a scan when you open a pull request, see a flagged dependency, apply the suggested version, and push a tiny follow-up commit without leaving the editor — avoiding trips to a web console or separate scanner and saving the time of context switching during a release fix.

This plugin provides a zero-dependency local chat UI for testing notification and messaging flows. It runs entirely on localhost, does not require API tokens or external services, and starts from a single command. You get a lightweight web UI that reads and displays messages, lets you type replies, and records message history to local files so you can replay scenarios. It creates mock endpoints and a local receiver so you can POST messages, simulate webhooks, and inspect incoming payloads and headers in real time. The UI shows timestamps, sender IDs, and raw JSON for each message. You can configure fake users, preset system messages, and send batches of messages to exercise retries, rate limits, or formatting edge cases. The tool logs all traffic to disk and shows a searchable history so you can trace a notification from send to display without flipping between logs and mail clients. It runs on a single machine and opens a browser tab for quick manual verification and exploratory testing. Imagine working on a mobile app notification flow: you can run the local server, trigger webhooks from your backend, watch messages appear, tweak payloads, and verify client behavior without deploying or swapping between a staging server and a third-party sandbox. That saves time and keeps work focused on the message formats and error paths you care about.

Postiz connects Claude Code to 28+ social platforms so you can schedule and publish from the command line. It handles OAuth account linking, token refresh, media uploads, and platform-specific fields (captions, hashtags, alt text, thumbnails) so you don't open a browser to post. You can create drafts, set publish times, and queue recurring posts across X, LinkedIn, TikTok, Instagram, YouTube and many more. The plugin reads CSV or JSON batches, maps columns to post fields, and uploads assets while respecting platform rate limits and retry policies. It records post IDs, timestamps, and delivery status, and exposes analytics like impressions, clicks, engagement rate, and watch time. You can export results to CSV or push them to a webhook for downstream reporting. Postiz generates campaign groups, applies templates and UTM parameters, and runs A/B test variants by swapping captions or thumbnails. It watches job status, surfaces errors with logs, and supports scheduled edits and deletes so you can correct a mistake before a post goes live. For a product launch, use Claude Code to batch-upload launch copy and video, schedule staggered posts to X, LinkedIn, TikTok and YouTube, and pull performance into a CSV — all without switching between platform dashboards, saving hours of manual uploads and tracking.

Agent SDK Dev gives you the repo, CLI commands, and example code you need to start building Claude-powered agents in minutes. It reads your language choice (TypeScript or Python), generates a project layout, wires in auth and API clients, and includes sample agent flows so you can run a working example without hunting for configuration details. The kit provides scaffolding for handlers, tools, and memory layers, plus ready-made hooks for logging, telemetry, and error handling. It adds linting rules, unit test stubs, and CI workflow templates so you can run code checks and tests from day one. The included examples show how to send messages, call tools, persist conversation state, and validate inputs. Use the CLI to run a local dev server, run tests, or generate new agent modules. The code is organized so you can swap components, add custom tools, or extend memory implementations without rewriting boilerplate. The repo maps network calls, environment variables, and deployment-ready Dockerfiles so you can build and package agents for staging or production. In a real sprint, you can scaffold a new agent, wire an external API, and run unit tests all from the same workspace. That saves time and prevents flipping between multiple templates, docs, and one-off scripts when you just need to iterate on behavior and get feedback fast.

This plugin connects Claude Code to Asana and exposes core Asana operations as callable actions. It reads projects, lists tasks, pulls task details, creates new tasks, updates fields, adds comments, attaches files by URL, marks tasks complete, and searches by assignee, tag, or custom field. The plugin maps Asana workspace, project, section, and custom field IDs so your code can reference them reliably. It supports pagination when listing large projects and returns structured JSON for tasks, subtasks, and dependencies. You can filter by completion status or due date, sort results, and batch-update multiple tasks. The plugin also watches for recent task activity so you can trigger flows when a task is assigned or a comment appears. Use it to build automation that assigns incoming bug reports to the right project, posts a comment with triage notes, and marks the task in a sprint board without opening Asana. In a daily standup script it saves time by pulling current sprint tasks and statuses so you don’t switch tools to prepare reports. GitHub: https://github.com/anthropics/claude-plugins-official

Build SumUp payment integrations for in-person and online checkout — covering card readers, mobile POS apps, and the full Cloud API.Want to add payments to your app? SumUp walks you through the whole process, whether you're ringing up sales at a physical register, letting customers pay online, or handling transactions behind the scenes through code. The plugin connects you directly to SumUp's live API and gives you everything you need to get started—pick from options like card readers for your phone, embedded checkout pages, server libraries in whatever language you code in, or even webhooks to track when payments come through.

Connects Claude Code to a Roslyn-powered C# language server and reads your project/solution to provide real-time type analysis, symbol indexing, and semantic highlights. It sends diagnostics as you type, runs code fixes, and reports errors and warnings from the same engine that compiles your code. Gives smart completions with overload lists and named-parameter suggestions, shows hover tooltips with summaries and inferred types, and lets you jump to definitions, implementations, and references across projects. It runs refactorings like Rename and Extract Method, applies formatting rules, offers signature help while you type, and exposes code actions so you can accept fixes without leaving the editor. Useful when you maintain a multi-project ASP.NET Core or library repo: you can rename a public API across projects, extract and test a method, and see compilation warnings inline instead of switching to Visual Studio. That saves context switching and keeps you working inside Claude Code while you edit, navigate, and fix code. The GitHub repo at zircote/csharp-lsp hosts the server and docs.

Adds maps, geocoding, routing, and device tracking through Amazon Location Service with full SDK examples and authentication setup. The bundle points to the official GitHub repo and includes sample code for web, Android, and iOS so you can embed a working map, test geocoding calls, and exercise routing without guessing which APIs to call. It embeds MapLibre-compatible map tiles, pulls place searches and reverse-geocode results, generates route requests and returns maneuvers and polyline data, and records location updates for device histories. You can create and evaluate geofences, check enter/exit events, draw markers and polylines, and compute distances and ETA from returned legs. The examples show how to throttle requests, page through search results, and handle rate-limit errors. The guide shows how to wire AWS SDKs, set up IAM roles or Cognito identity pools, request temporary credentials, and sign calls with SigV4. It explains region and resource ARNs, configures CORS for browser requests, and includes debugging tips for common mistakes like incorrect map style, mismatched region, or missing permissions. Sample snippets run locally with mocked credentials and include tests for offline behavior. For a delivery app you can use the samples to plot drivers on a single map, compute optimized routes per stop, and trigger geofence alerts when a driver approaches a customer — all without switching between a map provider and a separate geocoding or tracking tool. That saves time during development and avoids bouncing between dashboards when validating end-to-end behavior.

Endor Labs connects your code and CI/CD pipelines to a security scanner that reads repos, Docker images, Terraform and Kubernetes manifests, and pull requests. It runs static analysis and dependency checks, maps findings to specific files and lines, and returns a prioritized list of vulnerabilities with suggested fixes. The plugin pulls reports from the Endor Labs engine and shows exact remediation steps you can paste into PRs or issues. It checks container layers for unsafe binaries, scans IaC for misconfigurations, and tracks secret-like patterns across commits. You can ask it to re-scan a branch, filter results by severity or file path, and fetch historical reports for a given commit hash. The plugin also records evidence links back to the original rule and CVE entries so you can validate the discovery. The integration posts concise summaries you can include in CI logs, and it generates patch-ready snippets that update the offending lines. It flags policy violations that block merges and lets you mark findings as false positives or exceptions, keeping triage inside the same workflow. Imagine reviewing a large feature branch: instead of switching to a separate portal, you run the scan from your PR, see failing rules, copy suggested edits, and push fixes without leaving the code host. That saves time during reviews and prevents context switching between tools when closing security gaps before merge.

This plugin restores the explanatory tone developers relied on: Claude reads your code and comments, explains the reasoning behind each implementation decision, and highlights codebase patterns worth knowing. It annotates suggested changes with short rationales, points out trade-offs, and flags assumptions the assistant made when proposing edits. Use it when you want follow-up context alongside diffs or example implementations. The extension generates compact learning notes: it identifies repeating abstractions, maps where patterns appear, and calls out surprising dependencies or API contracts. It ties suggestions to code paths, explains why one approach is safer or faster in your repository, and shows where you may need to add tests or refactor to avoid technical debt. It also summarizes the impact of changes on performance, readability, and coupling. When you ask for code, responses include a step-by-step explanation of the decision chain, not just the final patch. The plugin marks optional changes versus required fixes, lists follow-up tasks, and provides short code examples illustrating the alternative approaches it described. Real-world example: reviewing a pull request that refactors authentication — instead of jumping to docs or chat, the assistant explains why a token cache was chosen, where to invalidate it, and which existing modules will break; that saves switching to a browser to hunt for context and reduces back-and-forth in code review.

Intercom connects your Intercom workspace to Claude Code with read-only OAuth so you can search and inspect conversations from the terminal. It reads conversation threads, pulls contact and company records, and opens the original Intercom URLs so you can jump back to the dashboard when needed. Permissions are limited to reading data only; nothing is written back. Use concrete queries to search by keyword, tag, assignee, and time range. The plugin returns message excerpts, metadata, and contact fields, and it maps conversations to companies and segments. It can list recent conversations for a contact, fetch the last N messages, and surface linked tickets or custom attributes that your team uses in Intercom. It analyzes support patterns by aggregating counts, surfacing frequent topics, and highlighting recurring tags or phrases across conversations. You can pull quick summaries for a ticket set, export a compact customer profile that includes last contact, open issues, and plan tier, and spot whether multiple contacts report the same problem. In practice you can run a search and assemble a customer handoff or bug report without opening the Intercom dashboard: an engineer can gather recent error reports from affected users, a support lead can compile weekly issue trends, and a CSM can build a profile before a call — all without switching tools, saving time and context switches.

Reads your repository and builds a concrete tracking plan: it scans front-end and back-end code, finds UI interactions, API endpoints, and database writes, and maps them to events, properties, and user traits. You get a structured schema that lists event names, required and optional properties, data types, and where each event should fire in code. It uses seven slash commands to run targeted tasks and a background agent that watches for code changes and rescans incrementally. Generates ready-to-install instrumentation: it spits out SDK wrapper code, helper functions, and example calls for over 25 analytics platforms including Segment, Amplitude, Mixpanel, and PostHog. It also creates type definitions and unit-test stubs so your devs can import tracking helpers, run tests, and avoid raw string event names scattered across files. You can pick platform-specific options or a neutral interface for multi-tool setups. Reports gaps and duplicates: the tool flags missing properties, inconsistent naming, and events that look redundant across pages or services. It produces a changelog of what it added or updated and links findings back to source files and git commits so reviewers can approve instrumentation PRs alongside feature code. Imagine a PM wanting weekly funnel numbers: instead of context-switching into analytics UIs and hunting for missing events, the team runs a slash command, reviews the generated schema and wrapper code, and merges instrumented changes with CI tests. That saves hours of back-and-forth and prevents shipping features without the right telemetry.

Adspirer Ads Agent connects to Google Ads, Meta (Facebook/Instagram), TikTok and LinkedIn accounts and exposes 91 tools you can call by chat. It reads account structure, pulls campaigns, ad sets, ads, keywords and audience signals. You can ask it to research keywords, map search queries to intents, generate headlines and descriptions, build responsive search ads, and draft creative briefs for image or video assets. Tell it to create campaigns with budgets, bids and schedules, set audience targeting and exclusions, add UTM parameters, and push live changes. It runs A/B test setups, applies automated bid rules, pauses low-ROI ads, increases budget for top performers, and fetches performance slices by campaign, creative or keyword. It also exports CSVs, generates consolidated cross-platform reports, and surfaces anomaly alerts when cost or conversions spike. It supports multi-account flows, reads conversion tracking, maps events across platforms, and stores change logs so reviewers can audit who ran which update. You can import campaign templates, export campaign builds, and sync creatives from a shared folder. The agent uses API credentials you provide and limits actions according to account permissions. In practice a growth manager saves time by asking the agent to run weekly optimizations, generate a single cross-platform report, and apply budget moves without switching between four web dash‑boards — cutting several hours of manual copying and reconciliation each week.

Scaffolds and validates AI agents using the Atomic Agents framework — specialized tooling and built-in best practice enforcement throughout the build process.Building AI agents doesn't have to be complicated. Atomic Agents gives you a complete workflow for creating intelligent agents from the ground up, with specialized helpers that guide you through schema design, planning out your architecture, reviewing code, and developing tools. It walks you through each step with clear guidance, teaches you skills as you need them, and keeps you on track with best practice validation so you actually build something solid.

This plugin lets you deploy and operate Railway projects from within Claude Code so you don't need to open the dashboard. Run commands to spin up services, push code, tail logs, inspect builds, and watch deployment status. You can create new services, run one-off containers, open a port tunnel to a running service, and roll back to a previous deployment from the terminal. It reads and writes environment variables and secrets, manages custom domains and SSL, and controls multi-region deployments. The plugin talks to Postgres, Redis, MongoDB, S3-compatible storage, and other Railway service types. It pulls service metadata, streams live logs, checks health, and shows resource counts and billing metadata when available. You can run migrations, trigger backups, scale instances, and run a bash shell inside any service. Commands include create service, up/down, logs, env:set, env:unset, deploy, rollback, and attach. It maps project state to readable responses, returns structured JSON when requested, and records deployment IDs so you can reference or revert them later. In practice, use it to rotate a secret, push a hotfix, and tail logs to confirm the fix without opening the Railway web UI or your CI pipeline. That saves minutes when you're troubleshooting incidents or iterating on a production bug fix and prevents context switching between chat, terminal, and the dashboard.

Equips Claude with investment banking knowledge and tools to build pitch decks, tear sheets, valuation workbooks and merger models like a junior deal team would. It reads company financials, maps line items to standard models, calculates multiples, DCF components and pro-forma consolidations, and formats results into export-ready tables and charts. It generates memorandums, executive summaries and transaction rationale text that follow common IB conventions and checklist items. The plugin also generates front-end code for client-facing deliverables so you can produce unique, production-ready presentations instead of one-size-fits-all templates. It emits responsive HTML/CSS and chart bindings, wires up data hooks to CSV or API sources, and includes clean JS for interactive charts and model toggles. It validates data types and flags mismatches so the code and numbers align before you hand off to design or engineering. It connects to common data sources, pulls company fundamentals and market data, runs sensitivity tables and scenario outputs, and records assumptions alongside source links. It can export model sheets to Excel, create printable PDFs of tear sheets, and generate a checklist of documents to request in diligence. In a live deal you can run a valuation, generate a one-pager and a client-ready slide, and produce the front-end preview without switching between Excel, PowerPoint and a separate dev tool. That single flow saves hours during prep and prevents manual copy-paste between tools when you need to send a deck or a model on short notice.

This plugin brings Eclipse JDT Language Server into Claude Code and runs the same analyzer used by Eclipse and VS Code. It reads your Java classpath, parses source and compiled jars, and reports syntax and type errors as you edit. You get hover Javadoc, parameter hints, and signature help that pull straight from your project's sources and dependencies. It sends and receives LSP requests for completion, goto-definition, find-references, workspace-symbols, and call-hierarchy. You can run refactor actions like rename, extract method, and move type; apply quick fixes such as adding imports or converting between stream and loop forms; and run organize imports and format actions against your codebase. The server watches project files, reads Maven/Gradle metadata, and updates the workspace classpath so diagnostics stay accurate after dependency or module changes. It also provides launch configuration suggestions and links to problem markers so you can jump from an error to the offending code, apply a fix, and re-run a build without leaving the editor. For example, when you open a large monorepo and need to rename a public class used across multiple modules, the plugin finds all references, applies the rename across files, updates imports, and runs quick diagnostics — avoiding the need to switch to Eclipse or a separate IDE to perform safe refactors and validation.

Build and deploy serverless applications on Cloudflare's global network using Workers, Durable Objects, and the Agents SDK. Includes Wrangler CLI integration for local development and MCP server support for seamless infrastructure management.

Kotlin LSP adds JetBrains' official Kotlin language server to Claude Code so your editor reads Kotlin project metadata, analyzes types, and reports diagnostics as you edit. It sends hover info, signature help, and smart completions that respect imports and type inference. It runs quick diagnostics for compiler errors, unresolved symbols, and common lint hints so you see problems before you run a build. It maps symbols across files with go-to-definition, find-references, and workspace-symbols, and it records document symbols for the file outline. The server applies safe rename and simple refactorings, suggests code actions like import fixes and intentions, and runs code formatting to match Kotlin conventions. It watches both .kt source files and Kotlin script files and understands multiplatform and coroutine-specific types. Configuration talks to your Gradle or Maven setup so the server resolves project dependencies and module classpaths. It pulls compiler options from your project and exposes settings for diagnostics and completion behavior. The plugin connects to the upstream repo on GitHub at https://github.com/Kotlin/kotlin-lsp for updates and issue reports. Use it when you work on Android or JVM Kotlin in Claude Code: it saves time by surfacing type-aware completions and jump-to-definition without opening IntelliJ, so you avoid switching tools for quick edits, debugging small bugs, or iterating on build scripts.

Turn Claude into a hands-on coding mentor that pauses at concrete decision points and asks you to act. This plugin watches the code generation flow, identifies spots like error handling, input validation, loop logic, or API wiring, and inserts prompts asking you to write 5–10 lines of code or choose between two approaches. It records your answers and continues only after you confirm or paste your snippet. The tool checks your snippet for syntax, runs quick static checks, and shows inline diffs so you can compare the model’s suggestion with your code. It can force you to pick architecture alternatives, name variables, or write unit test stubs. It keeps the session interactive by tracking which concepts you’ve practiced and which ones the model handled. You get a session log that maps each pause to the learning objective, the code you wrote, and the model’s alternative. Use it to replay steps, export exercises, or generate follow-up quizzes. It supports CLI-style tasks, web handlers, and small refactors. In a real project, the plugin saves time during code reviews: instead of switching to an editor to try a fix, you write and validate the snippet right inside Claude Code, then continue the guided session without toggling tools or losing context.

Reads your existing GCP account and Terraform state, parses resource definitions, and pulls actual billing data. It maps GCP services (for example Compute Engine, GKE, Cloud SQL, Cloud Storage, IAM) to equivalent AWS resources (EC2/EKS, RDS, S3, IAM) and flags constructs that don’t have 1:1 matches. The tool checks Terraform modules, identifies hard-coded GCP providers, and generates a migration inventory with resource counts, inter-dependencies, and estimated data transfer paths. Fetches current AWS on-demand and reserved pricing and applies region-specific rates to give a line-item cost comparison. It generates Terraform sketches or CloudFormation snippets for the mapped AWS resources, and annotates them with the changes you’ll need (machine types, networking, IAM roles). The planner validates basic constraints like subnet sizes, VPC peering, and service limits and reports likely blockers. Produces a five-phase migration plan: discovery, design, proof-of-concept, data sync and cutover, and validation & rollback. Each phase includes concrete commands, Terraform workspaces to run, a recommended cutover window, and smoke-test steps. It also evaluates whether a lift-and-shift, re-platform, or stay-put option is cheaper and safer, and it records the confidence level of each recommendation. Imagine migrating a multi-region web app with GKE, Cloud SQL, and BigQuery: the plugin reads your Terraform state, maps clusters to EKS, converts SQL to RDS, pulls AWS pricing, and spits out a step-by-step cutover plan. That saves hours of manual mapping, spreadsheet pricing, and console hopping, and avoids bouncing between cloud consoles and separate cost tools during planning.

Installs the rust-analyzer language server into Claude Code and connects your workspace to Rust's official analyzer. It reads Cargo.toml and source files, sends diagnostics and inlay hints, and updates results as you edit. You get hover type info, go-to-definition, find-references, and real-time autocomplete backed by actual crate metadata. It runs code actions and assists like implement trait, generate method stubs, convert to async, and apply simple refactors such as rename and extract function. It shows borrow-checker-aware diagnostics and lifetime suggestions derived from analyzer checks. It also formats with rustfmt and exposes semantic tokens for precise highlighting. The extension watches file changes and responds to Cargo updates so completions and imports stay accurate. It offers apply-and-test workflows: request a refactor, run cargo check or clippy, see updated diagnostics, and accept fixes without manual steps. It maps quick-fix suggestions to concrete edits you can preview before applying. In practice, use it when you're iterating on a tricky lifetime or implementing a trait: you can jump to related types, accept a generated impl, run cargo check, and fix remaining diagnostics all inside Claude Code instead of switching to a terminal or another IDE. It saves frequent context switches and keeps edits and checks in one place.

Fastly Agent Toolkit gives Claude working knowledge of the Fastly CDN platform and the Fastly Agent Toolkit GitHub repo. It reads and writes VCL snippets, runs the VCL linter, builds and runs Compute@Edge projects locally, and maps service versions to active configurations. You get six focused tools that cover code authoring, linting, local Compute execution, service management, cache/security rules, and deployment via the Fastly CLI and API. It opens and edits VCL files, checks them for syntax and best-practice issues, and suggests specific fixes. It runs your Compute app locally, watches console output, and helps you iterate by rebuilding and reloading the local runtime. For services it pulls service lists, inspects active backends and dictionaries, and creates or clones service versions. For delivery and ops it checks and updates caching rules, manages ACLs and TLS settings, and posts deploy commands through the CLI or API. It pulls real-time logs and metrics when available, and it records deployment IDs and version numbers so you can track rollbacks and audits. Imagine editing VCL, testing a Compute worker, and deploying a version without leaving your terminal or switching between the Fastly docs, CLI, and a separate editor. That flow saves time when you need to fix a cache rule, verify logs, and push a hotfix during a production incident.

More than a linter — 40+ analyzers including AST parsing and security scanning, automatically incorporating your own project guidelines into every review.CodeRabbit gives you a second pair of AI eyes on your code right inside Claude. It catches bugs, security issues, logic problems, and edge cases that are easy to miss by combining specialized analysis with over 40 integrated code analyzers. The tool digs deep into your code's structure and relationships, then automatically applies your project's coding guidelines and conventions to make sure the review actually reflects how you work.

The Stripe plugin connects Claude to your Stripe account so the assistant can call Stripe APIs, read test-mode objects, and generate runnable code snippets that match your live setup. It creates and updates customers, PaymentIntents, Checkout sessions, subscriptions, invoices, refunds, and Connect accounts. It reads webhook endpoints, verifies signatures, and can replay test events so you can validate your event handlers without flipping between the code editor and the Dashboard. When you ask for example code the plugin returns SDK-ready samples (Node, Python, Ruby) that include keys, parameter shapes, and error handling. It inspects recent logs, pulls specific events, and maps them to the handlers you already have. It checks API versions and suggests the correct request format for the version your account uses, and can generate curl commands or test fixtures for unit and integration tests. Imagine implementing subscription proration and webhook-driven invoice logic: the assistant pulls a recent invoice event, verifies the signature, generates a tested handler that updates your database and retries failed payments, and provides a curl command to replay the exact event. That saves you from switching to the Stripe Dashboard, reading scattered docs, and guessing at request formats while you code and test.

Pinecone connects Claude Code to your Pinecone vector database so you can create, inspect, and modify indexes without leaving the editor. It lists available indexes, reads index metadata, creates and deletes indexes, and uploads (upserts) or deletes vectors. You can fetch vectors by id, run similarity queries with text or precomputed vectors, and retrieve raw match scores and metadata for each hit. The plugin sends queries in plain language or vector form, maps query results back to your data, and returns the original payloads and namespace info. It supports batching for bulk upserts, paginated fetches for large result sets, and optional score thresholds to filter matches. You can watch operations and get status responses for long-running jobs. Use it when you want to prototype a semantic search feature, iterate on index schemas, or debug retrieval quality without switching to another console. For example, while building a customer support search you can upsert transcripts, run natural-language queries, inspect top matches and adjust namespaces or metadata on the spot — saving the time of toggling between Claude Code and the Pinecone dashboard.

Dedicated agents for quality and compliance that plug into every stage of your software lifecycle — from writing tests to security and regulatory review.Qodo Skills catches code issues early by pulling your repository's coding rules right into your editor before you commit anything. It syncs with Claude Code and the Qodo platform, so you can see what your team expects and fix problems on the spot. Rules come in three levels—errors you have to fix, warnings you should pay attention to, and recommendations worth considering—and they're tailored to your organization, specific repos, and even particular folders, so you get exactly the guidance that matters for each part of your codebase.

Adds ElixirLS to Claude Code so your editor reads and reports real Elixir and Phoenix diagnostics inside the workspace. It runs the Elixir Language Server against your project, watches .ex, .exs and .heex files, and surfaces compiler errors, warnings, and lint-style issues inline. You get code completions, go-to-definition, find references, and hover type hints drawn from @specs and inferred types. The server runs mix compile and the language server diagnostics pipeline, maps line-and-column errors back to the editor, and updates results as you save files. It runs code actions and can trigger mix format or organize imports where supported. Completions include module names, functions, struct fields, and Phoenix template helpers; hover shows function specs, inferred return types, and documentation if available. Use it when editing Phoenix .heex templates and backend .ex modules without switching to a separate IDE. For example, when iterating on a controller and template, ElixirLS reports a missing assign and a compile error from the associated module, so you fix both places in Claude Code instead of jumping to another tool or running repeated mix compile cycles locally.

Full Firebase access from the terminal. This plugin connects Claude Code to your Firebase projects so you can list projects, switch targets, and set environment variables without opening the Firebase console. It reads project metadata and shows active configs. You can read and write Firestore documents, run queries, and batch updates. It manages Authentication users (create, delete, list, update claims), uploads and downloads Storage files, and manipulates Realtime Database entries. It also reads logs and shows function invocation details. Deploy and rollback Cloud Functions, publish hosting sites, run the local Emulator Suite, and run CI-style test deploys. It reads and edits firebase.json, sets hosting rewrites, updates Firestore rules, and runs rules simulators. The plugin calls the Firebase CLI under the hood and streams command output back to Claude Code. In a typical workflow you can inspect a failing function log, patch code, deploy the new function, and run an emulator-triggered test without switching to a browser or separate terminal — useful when you want to fix a production bug while staying inside your IDE and avoiding context switching.

A full memory infrastructure layer — manage vector embeddings and persistent memory spaces through natural language using GoodMem's Python SDK and MCP tools.GoodMem gives your AI agents a genuine memory system—think of it like giving them a notebook they can actually search through. It lets you store information as vector embeddings, retrieve it when needed, and find semantically similar content in seconds. With 41 tools organized into 10 functional areas, plus a built-in library of 79 pre-configured models, you can get up and running without wrestling with API endpoints or dimensions.

Connect Claude Code to your Linear workspace to create, update, and move issues without leaving your editor. The plugin authenticates with Linear, reads your teams and projects, sends new issues with titles, descriptions, labels, assignees, and estimates, and updates existing issues' state and fields. It also pulls issue details and comments so you can reference tickets while coding. You can search across workspaces, filter by sprint, label, or assignee, and open the matching issue in a single command. It watches for status changes you request and runs transitions on the board (e.g., "move to In Progress" or "archive"), and it records links to commits or PRs you paste into an issue. It uses the linear-cli pattern on GitHub to map local commands to API calls, so permissions and rate limits behave like the official client. The plugin handles pagination, resolves user names, and surfaces API errors with actionable messages you can copy into a console for debugging. In practice, you can run a code review and update the ticket state, add the merge link, and assign follow-ups without switching to the Linear web app. That saves time when fixing multiple small bugs during a bug bash or when triaging crash reports during a sprint—no tab switching, fewer context losses.

Zapier connects Claude Code to over 8,000 apps so you can discover and run automations without writing glue code. It reads your available Zapier apps and actions, lists triggers and fields, and runs chosen actions directly from the conversation. You can search for app actions, map Claude outputs into Zapier fields, and execute create, update, or search operations on third-party services. It handles the OAuth flow through your Zapier account, pulls metadata about action inputs and outputs, and returns structured results you can inspect or pass to further steps. You can run single actions on demand, test mappings with sample data, and view execution responses including IDs and status. The integration also supports trigger polling so you can fetch recent events and act on them inside Claude Code. Imagine drafting an email and having Claude build the contact, log the message in your CRM, and create a follow-up task in your project board without opening Zapier or multiple apps. That saves time when you need to push data across services during a coding session or a planning meeting and prevents constant switching between tools to run or test automations.