Browse plugins

ECC is a comprehensive agent harness platform for Claude Code with 68 agents, 292 skills, and 94 legacy command shims, featuring reusable hooks, rules, and MCP conventions for engineering teams. It provides PostToolUse, PreToolUse, PreCompact, SessionStart/End, and Stop lifecycle hooks along with operator workflows integrated directly into Claude Code.

Hookify creates custom hooks to prevent unwanted behaviors by analyzing conversation patterns or explicit instructions, using simple markdown configuration files with regex pattern matching. It supports four hook events (PreToolUse, PostToolUse, UserPromptSubmit, Stop) and provides commands to generate rules, list configurations, and interactively manage hook behavior without requiring restarts.

A comprehensive toolkit for developing Claude Code plugins with seven specialized skills covering hooks, MCP integration, plugin structure, settings, commands, agents, and skills. Includes guided workflow commands, example scripts, validation utilities, and best-practice documentation for building production-ready plugins.

Caveman compresses AI agent communication by shortening prose while preserving code, commands, and exact error messages, reducing input tokens by 33.2% and costs by up to 54% across multiple agents and platforms. It provides six optimization modes (Say Less, Read Less, Auto, Blocks, Waste Fixes, Browse) that work by hooking into SessionStart, SessionEnd, and UserPromptSubmit events to strip verbosity from both agent responses and data before model processing.

The understand-anything plugin leverages AI agents to analyze, visualize, and explain codebases by orchestrating multiple skills that examine project structure, dependencies, and code semantics. It integrates grep and Node.js tools to extract codebase information and triggers understanding workflows at session start and after tool use.

Impeccable is a frontend design fluency plugin that provides 24 commands for design review, audit, and critique, with built-in anti-pattern detection to catch common frontend issues. It hooks into Claude Code's tool workflow and session events to automatically apply design checks as part of development.

ruflo-core is a foundation Claude Code plugin that registers the ruflo MCP server (314 tools) providing memory, embeddings, hooks, neural networks, autopilot, browser automation, agent orchestration, and system access, plus 4 generalist agents and 5 helper skills for plugin discovery and project initialization. It implements cross-cutting contracts for session management, 3-tier model routing, and a curated catalog of 32 sibling plugins with 7 architecture decision records.

The ruflo-cost-tracker plugin provides token usage tracking, USD cost attribution per agent/model, and budget alerts with tiered warnings (50/75/90/100%) that can trigger hard stops. It includes 24 skills for cost analysis, optimization recommendations, anomaly detection, burn-rate trending, PR regression detection, and multi-provider ledger reporting.

Context7 fetches current documentation directly from source repositories, automatically resolving library identifiers and retrieving version-specific code examples when you ask about popular frameworks and libraries. The plugin provides manual commands, auto-triggering skills, and a dedicated docs-researcher agent to keep your context fresh and accurate without relying on stale training data.

This plugin enforces Cedar-based authorization policies on every Claude Code tool call and generates Ed25519-signed audit receipts that are independently verifiable offline. It prevents unauthorized tool execution before it happens and maintains a hash-chained trail of all decisions with cryptographic proof.

This plugin gates PR reviews, issue comments, merges, CI workflow edits, and other sensitive review-surface actions behind mandatory human approval, using Cedar policies and Ed25519-signed receipts for audit compliance. It prevents AI agents from taking unvetted actions that affect code review integrity and other contributors by requiring an explicit approval flag or slash command before high-impact tool calls execute.

A Claude Code plugin that runs vulnerability scanning entirely within your session using a team of 9 agents to map architecture, build threat models, hunt for vulnerabilities, and verify findings before reporting. Confirmed findings are transformed into targeted patch files that you review and apply at your discretion.

Hookify creates custom hooks to prevent unwanted behaviors by analyzing conversation patterns or applying explicit rules defined in simple markdown configuration files. It supports regex-based pattern matching across multiple event types (bash commands, file edits, user prompts) with configurable warn or block actions.

Codex is a Claude Code plugin that enables code review and task delegation through a set of commands, agents, and skills integrated into the Claude Code environment. It leverages local Node.js execution to support automated code analysis and workflow automation.

Brand Voice searches across Notion, Google Drive, Confluence, Gong, Slack, and meeting transcripts to extract your company's brand identity, then synthesizes it into LLM-ready guidelines and validates all AI-generated content against them. Every piece of content—sales emails, proposals, LinkedIn posts—stays on-brand automatically while adapting tone by context.

This plugin turns Anthropic's reference skill into a full domain framework for building and managing Claude Managed Agents, with deterministic scaffolders that compile user goals into single-pass workflows or bounded iteration loops. It orchestrates agent interviews, staging, grading, and scheduled deployments entirely through stdlib tools and BYOK curl scripts, never touching API keys directly.

A four-tier memory ladder for Claude Code that captures and promotes session insights through recurrence-earned promotion gates (L0→L1→L2→L3), with human-gated adoption, redaction safety, and contradiction detection. Ships hooks for SessionStart/SessionEnd/UserPromptSubmit, five stdlib Python scripts (memory_core, memory_extract, memory_promote, memory_inspect, validate_examples), a /cs:memory command, and a cs-memory-curator agent.

This plugin compacts a conversation into a structured handoff document for another agent, with configurable storage locations, secret redaction, and automatic loading on the next session. It enforces a mandatory five-section checklist, suggests relevant skills for follow-up work, and uses SessionStart/SessionEnd hooks to ensure context is preserved across agent handoffs.

A collection of 9 project management skills including Senior PM, Scrum Master, Jira Expert, Confluence Expert, Atlassian Admin, and template scaffolder roles, with integrated Atlassian MCP for direct Jira/Confluence operations and agentic delivery workflows. The plugin provides an 8-lane deterministic router, delegation-governance gates, and flow metrics with Monte Carlo forecasting for project delivery optimization.

This Playwright testing toolkit generates production-grade tests from specifications, fixes flaky failures, and migrates test suites from Cypress or Selenium—all via 3 specialized agents, 10 skills, and 55+ ready-to-use templates. Optional TestRail and BrowserStack integrations (manually enabled) enable test-case syncing and cross-browser reporting.

This Claude Code plugin automates the curation of auto-memory by analyzing patterns, promoting proven learnings to enforced rules in CLAUDE.md, and extracting recurring solutions into reusable skills. It provides five slash commands—/si:memory-review, /si:promote, /si:extract, /si:memory-status, and /si:remember—along with error-capture hooks to maintain a structured self-improvement loop.

Claude SEO is an open-source Claude Code plugin that runs 26 sub-skills and 19 specialist agents in parallel to analyze technical SEO, content quality, schema markup, local SEO, e-commerce, and international SEO with recommendations grounded in Google's primary-source guidance. It includes AI-search optimization, Core Web Vitals analysis, backlink evaluation, and produces falsifiable audit reports with prioritized action plans.

claude-obsidian is a local-first knowledge system that captures sources, creates linked Obsidian notes with provenance ledgers, and retrieves grounded answers from your vault without uploading files. It provides 15 skills for ingestion, querying, linting, and maintenance with explicit consent workflows and optional methodology modes.

WhoDB is a Claude Code plugin providing database management tools for querying, exploring schemas, analyzing data, and optimizing queries across PostgreSQL, MySQL, SQLite, MongoDB, Redis, ClickHouse, Elasticsearch, and more. It includes specialized agents for database analysis and query optimization, with configurable security modes and MCP server deployment via npm, Docker, or local binary.

autoharness is a self-learning skill layer for Claude Code that automatically discovers, merges, and validates skills learned from real agent sessions rather than offline benchmarks. It maintains a clean skill library by pruning unused skills and updating actively-used ones, touching only the skills it generates itself.

Claude Octopus is a plugin that orchestrates research, code review, and quality gates across Claude and up to ten external AI providers (Codex, Gemini, Antigravity CLI, Copilot, Qwen, Ollama, Perplexity, OpenRouter, OpenCode, and Grok) with consensus voting to catch blind spots before shipping. It delivers a four-phase workflow (Discover → Define → Develop → Deliver) with 32 specialized personas, 51 commands, 63 skills, and multi-LLM council deliberation modes for escalated decisions.

Ars Contexta generates a personalized knowledge management system through conversational setup, creating markdown vaults with wiki links, processing pipelines, automation hooks, and domain-native documentation—all derived from how you describe your thinking and work. The plugin provides 10 skills for extracting insights, finding connections, and maintaining your vault, plus a 6-phase pipeline that mirrors Cornell note-taking with a meta-cognitive layer for continuous system evolution.

SocratiCode provides semantic code search, dependency graph analysis, and context artifact exploration to give AI assistants deep understanding of entire codebases with zero configuration and no external API keys required. It works as a Claude Code plugin, MCP server, or VS Code extension, automatically indexing code at scale and keeping the index updated through file watchers across sessions.

Claude Code Harness enforces a disciplined delivery loop—plan, work, review, release—with pre-execution safety gates that adjudicate every tool call before it runs. It provides 4 agents and 21 skills including core verbs (/harness-plan, /harness-work, /harness-review, /harness-sync, /harness-release) to keep specifications, test coverage, and review independent from implementation, with two safety layers: a non-overridable runtime floor and configurable guardrails (R01–R15).

Pro Workflow is a complete AI coding system with self-correcting memory, persistent SQLite-indexed research wikis, and an auto-research loop that learns from corrections across sessions. It provides 41 skills, 8 agents, 23 commands, and intelligent hooks that inject relevant knowledge and enforce quality gates without requiring API keys or external services.

This plugin brings AWS Startup Solutions Architects' patterns directly into Claude, offering stage-aware architecture advice, guided building flows, AI agent runtime selection, and phased migrations from Azure/GCP/Heroku to AWS—including LLM stack rewrites to Amazon Bedrock. It includes 11 skills covering architecture review, infrastructure scaffolding, cost planning, Terraform quality gates, and access to AWS Activate credits and 60+ startup partner offers.

brand-forge generates on-brand logos, social templates, and marketing graphics as vector SVGs without requiring any API keys or external accounts. The plugin stores a visual brand profile (colors, typography, logo rules) and applies it consistently across all outputs, with optional AI raster imagery via Gemini or OpenAI.

Content Multiplier transforms a single source—post, transcript, or idea—into a week of on-brand content across multiple channels and languages using two subagents (strategist and brand guardian) to plan, draft, and enforce consistency. It runs entirely inside Claude Code with no external API keys or accounts required, offering slash commands for brand setup, single-source multiplication, multi-week campaign planning, localization, and QA review.

This GitHub Actions plugin automates secure CI/CD workflows for Google Cloud and Vertex AI deployments, enforcing Workload Identity Federation (WIF) for keyless authentication and comprehensive security best practices. It provides pre-commit validation hooks, post-deployment health checks, and IAM least-privilege enforcement to ensure production-ready pipelines.

Sugar is a Claude Code plugin that adds persistent memory, cross-session context, and autonomous task execution to AI-assisted development workflows. It discovers work from error logs and GitHub issues, manages tasks in a SQLite backend, and coordinates autonomous development through specialized agents.

Tonone is an open-source AI team of 100 specialist agents that installs into Claude Code, covering engineering, product, operations, design, security, and data science disciplines to enable solo founders to run company-scale work. It provides 189 skills organized around 31 specialized agents across infrastructure, backend, frontend, ML/AI, security, DevOps, observability, and compliance domains, executable through slash commands and markdown workflow documents.

x-bug-triage-plugin is a closed-loop bug triage pipeline that ingests X/Twitter complaints, clusters them, scans for repository evidence, routes to owners, and files GitHub issues with human confirmation at each step. It provides a terminal-driven CLI interface with a single MCP server (19 tools) orchestrated by Claude agents, requiring only bun, an X API token, and GitHub credentials.

pstack is a skill stack of 63 markdown instructions and 4 agents that route your goal to specialized workflows: reproduce bugs, architect designs, race candidate solutions, review diffs, and polish prose. It runs locally without telemetry, injecting its mandate via SessionStart hook and shell scripts for PR orchestration and worktree auditing.

This Claude Code plugin provides integration with Stripe's development capabilities through MCP, enabling developers to interact with Stripe APIs directly within Claude. It includes 10 skills, 1 agent, and 2 commands for managing Stripe operations, with shell execution support and multiple hook points for workflow automation.

This Claude Code plugin provides 6 agents and 12 reusable skills for enhanced development workflows, including deep research, image generation (via Gemini and OpenAI), GitHub automation, brainstorming, and YouTube transcription. It requires npx and integrates with external APIs for image generation and research capabilities.

Engram is a learning system that turns Claude into a Socratic tutor, verifying your understanding through free-recall challenges and scheduling review sessions using FSRS-4.5 spaced repetition. It keeps you accountable to what you actually learn—with receipts—across nine agentic platforms including Claude Code, OpenAI Codex, OpenCode, and multiple others.

A universal Claude Code workflow plugin with 7 specialized agents (code-reviewer, debugger, docs-writer, security-auditor, refactorer, test-architect, orchestrator), 26 commands, and 14 skills for automating code review, testing, debugging, documentation, security audits, and refactoring across any software project. It integrates with bash and Python, runs hooks on key workflow events, and is compatible with Claude Code, Cursor, Codex, and 35+ AI agents via skills.sh.

This plugin extracts video frames via ffmpeg and audio via configurable backends (Gemini API, local Whisper, or OpenAI), sending both to Claude for direct multimodal understanding. It supports YouTube URLs, adaptive parameter selection based on user intent, and offers an interactive setup wizard for configuration.

This plugin provides Git and GitHub workflow automation through 4 agents and 7 skills, handling commits, pull requests, code reviews, and comment resolution with built-in safety hooks. It integrates validation tools for commit types, visual proof requirements, and AI attribution checks directly into your development workflow.

The salesforce-development plugin provides AI-powered Salesforce platform development in Claude Code, auto-detecting your environment and injecting org context to enable natural-language creation of Apex code, metadata, flows, deployments, and security configurations. It combines 37 skills, the Salesforce CLI, and Salesforce-hosted MCP servers to resolve capabilities across metadata, deployment, reporting, and org lifecycle management.

This plugin enables Claude to build and modify Power Apps Canvas Apps by connecting to an app open in Power Apps Studio via the Canvas Authoring MCP server. The agent can create screens, configure controls, set up formulas, manage connectors, and define data sources directly within the Power Apps environment.

This plugin scaffolds and deploys Power Apps mobile applications using Expo and React Native, enabling developers to build native mobile experiences that connect to Power Platform data through Microsoft's native host package. It automates app generation, screen design, native capability configuration, and connector wiring via agent-driven skills that integrate with Azure authentication and Entra app registration.

The model-apps plugin builds and deploys complete model-driven Power Apps end to end, with /app-builder generating whole apps (tables, relationships, forms, views, charts, security roles) from natural language and /genpage creating generative pages using specialist agents for planning and parallel code generation. It requires PAC CLI > 2.10.0, Azure CLI, and Node.js LTS, integrating with Power Platform via the vendored cds-maker-sdk and leveraging feature flags for experimental capabilities like custom API calls and telemetry.

A comprehensive Claude Code plugin for creating and deploying Power Pages code sites (SPAs) using React, Angular, Vue, or Astro, with integrated workflows for data modeling, backend integration, authentication, and ALM orchestration. The plugin provides 35 AI-driven skills covering the full lifecycle from scaffolding and development to deployment, testing, and cross-platform migration, leveraging Node.js, PAC CLI, and Azure CLI.

craftsman is a Claude Code plugin that enforces minimal-diff coding, root-cause debugging with recurring-bug detection via graphify, and environment-quirk memory across sessions. It provides ten agents, seven skills, two slash commands (/craftsman:init and /craftsman:quick), and a cross-platform hook system to ensure honest completion reports and ask-before-writing project scaffolding.

fable-baton orchestrates Claude Code sessions with Fable 5 as the decision-maker while routing labor to tiered subagents (Opus/Sonnet/Haiku) based on task complexity and cost. It enforces delegation through session policies, per-prompt reminders, and activity-triggered notices to prevent the model from reverting to expensive inline work.

ForkMind treats AI conversation context windows like Git repositories, enabling you to capture, branch, and regression-test LLM calls as a directed acyclic graph. It runs locally via Ollama or OpenAI-compatible APIs, with an integrated MCP server that lets agents query their own conversation history for debugging and comparison.

GodotPrompter is a Claude Code plugin that equips AI agents with 55 domain-specific skills for Godot 4.x game development, covering architecture, gameplay systems, physics, animation, networking, and both GDScript and C# patterns. When activated, it automatically detects Godot projects and injects skill-routing guidance that helps agents follow Godot best practices instead of generic coding advice.

claude-council is a Claude Code plugin that queries multiple AI coding agents (Gemini, OpenAI, Grok, Perplexity, Kimi, OpenRouter-routed models, and local Ollama) in parallel and displays their responses side-by-side with a synthesis of agreements and divergences. It helps developers cross-check coding decisions, debug problems, and review security by consulting diverse AI perspectives without requiring any API keys if using local tools or CLI-based providers.

PM-Skills is a curated library of 68 best-practice product management skills covering the complete product lifecycle (discover through iterate), plus 6 sub-agents, 12 workflows, templates, and 200+ sample outputs that establish quality standards. It integrates with Claude Code, Codex, Cursor, Windsurf, Copilot, and Gemini CLI via slash commands, workflow orchestration, and skill chaining.

A specialized Claude Code plugin providing 26 agents and 51 skills for Elixir, Phoenix, and LiveView development with Iron Laws verification and Tidewave MCP integration. The plugin enforces development guardrails through hooks and shell-based tooling for safety checks, dependency auditing, and intelligent task routing.

Ralph Speckit enables spec-driven development in Claude Code using the GitHub spec-kit methodology, guiding projects through constitution-first phases: specify, plan, tasks, and implement. The plugin manages feature branches, state persistence, parallel task execution, and autonomous implementation via a stop-hook loop with built-in QA verification.

ralph-specum enables spec-driven development by decomposing feature requirements into executable tasks, with research, design, and autonomous implementation phases. It orchestrates multi-spec workflows through 16 commands, 10 agents, and hooks that coordinate spec context loading and task execution guards.

MisakaNet is a git-backed failure memory for AI coding agents that stores and retrieves verified debugging lessons from previous failures, enabling agents to find pre-verified solutions rather than debugging from scratch. It provides search via an MCP server with evidence-graded lessons and an intake mechanism to turn new failures into shared knowledge.

Allium is a specification language and Claude Code plugin that maintains a formal behavioral spec alongside code, using agents to elicit requirements forward from intent or distill them backward from existing code, then generates tests and catches design gaps through CLI validation. It closes the agentic coding loop by providing a persistent, formally-verifiable contract between spec, tests, and implementation that survives across sessions.

Episodic Memory enables semantic search across Claude Code, Codex, Cursor, opencode, and Oh My Pi conversations, allowing AI assistants to recall past discussions, decisions, and architectural patterns to provide more informed suggestions across sessions. The plugin automatically indexes conversations at session end and exposes natural language search capabilities through MCP tools to find relevant context even when exact keywords weren't used.

This plugin provides structured implementation planning with interactive annotation review and autonomous plan execution capabilities. It uses a command, agent, skill, and hook (on PreToolUse) to guide multi-step workflows, requiring only python3.

Maestro is a multi-agent development orchestration platform that coordinates 39 specialist agents through a 4-phase workflow (design dialogue, design review, implementation planning, and execution) with native parallel subagent dispatch and persistent session management. It provides standalone commands for code review, debugging, security audits, performance analysis, SEO audits, accessibility audits, and compliance checks, all powered by a Node-based MCP server.

AgentOps provides engineering guidance for Claude Code agents through behavior-driven planning, shared domain language, and independent validation mechanisms. The plugin includes 4 agents and 29 reusable skills that enforce policies via hook-based dispatching to improve coding agent reliability and consistency.

AgentOps provides DevOps discipline for AI coding agents through behavior-driven planning, shared domain language, and independent validation using a Plan-Implement-Validate loop. It includes 30 reusable skills, 4 agents, and tool-call guards to help agents produce consistent, well-tested work aligned with stated intent.

This Claude Code plugin provides workflow development tools through 5 agents and 51 skills for building automation and processing pipelines. It includes a SessionStart hook and shell execution capabilities to support complex workflow orchestration within Claude.

This Claude Code plugin transforms Claude into a business operating system with 66 skills and 21 agents managing communications (WhatsApp, Email, Slack, Telegram), projects, AWS infrastructure, revenue (Stripe, RevenueCat), e-commerce (Shopify), marketing (Klaviyo, Meta, GA4, GSC), monitoring (Datadog, New Relic, OTEL), and voice services (Bland AI, ElevenLabs, Whisper). It includes an interactive command center dashboard (/ops), autonomous YOLO mode with parallel C-suite agents, specialized subsystems for A&R analysis (/ops:ops-ar), GTM planning, macOS diagnostics (/ops:ops-mac), smart home control (/ops:ops-home), UniFi networking (/ops:ops-unifi), and safety hooks for secret detection, destructive command blocking, and post-merge deploy auto-fix.

Connect 9,000+ apps and 40,000+ actions to your AI workflow through a guided MCP integration that lets you discover, enable, and execute Zapier actions directly from your client. The plugin provides onboarding, live demos, real-life workflow setup, and health checks to automate tasks across Gmail, Google Calendar, Slack, Jira, Notion, HubSpot, Linear, and other integrated services.

EvanFlow is a TDD-driven orchestration system with 16 skills and 2 custom subagents that guides software development from brainstorm through implementation via checkpoints (design approval, plan approval, post-iteration review), ensuring you stay in control without auto-commits. The loop runs vertical-slice TDD per task, supports parallel coder/overseer review for independent units, and stops short of every git operation to await your direction.

This plugin provides guardrails and debugging tools for research workflows, catching AI mistakes in paper reproduction and experiment tracking before they become costly. It includes citation validation, LaTeX checking, timezone handling, and evidence-first experiment comparison through shell-based guards and hooks.

A Claude Code plugin and agent skills toolkit that teaches Claude to author, validate, and visualize Open Knowledge Format (OKF) bundles—portable markdown knowledge with YAML frontmatter that humans and agents can both read and maintain. Includes a deterministic conformance checker, interactive graph renderer, GitHub Action support, and an MCP server for read-only knowledge access.

NextBoard is a PCB hardware solution design agent that takes product requirements and outputs reviewable, implementable PCB schematics through a structured 7-stage workflow including requirement freezing, architecture selection, component sourcing, and multi-dimensional review. The agent automatically analyzes chip solutions, performs component selection, generates BOMs with pricing, creates module schematics, and produces comprehensive technical deliverables including markdown, datasheets, and PDF documentation.

SupaConductor is a multi-agent orchestration plugin for Claude Code that automates planning, execution, and quality checks to turn feature requests into completed code — coordinating 15 agents, 4 evaluators, and a "Board of Directors" across 39 commands and 42 skills. It handles task decomposition, parallel execution, code review, and automated fixes without requiring manual re-prompting or external service keys.

UI Craft is a design engineering system for AI coding agents that applies opinionated craft rules and acceptance criteria to prevent low-quality UI output. It provides four rungs of capability—from default-better prompts through persistent design context to CI/review gates—plus a scoreable design critique using Nielsen heuristics and classic design laws.

Architecture Studio is a local-first framework for AEC firms to build governed AI workflows with persistent studio and project memory, bundling 7 agents and 50 skills for site planning, zoning, specifications, sustainability, and materials research. The plugin initializes portable workspaces, maintains linked project records, and provides extension points for firm-specific and project-specific skills that remain user-owned outside the plugin cache.

AI Team OS transforms Claude Code into a multi-agent team operating system with 155 MCP tools, 25 agent templates, persistent task management, and autonomous loop execution across lifecycle hooks. It coordinates complex projects through team orchestration, task walls, meetings, memory store, and a company-style execution engine with health monitoring and self-healing capabilities.

This Claude Code plugin integrates the Antigravity CLI (Gemini) as a collaborating sub-agent, routing deterministic, high-volume work (scaffolding, test generation, migrations, web/Vertex AI Search) to Gemini while Claude handles requirements, architecture, verification, and review. Hybrid agentic engineering reduces token costs by routing cheaper bulk work to Gemini while keeping the hard judgement calls on Claude.

Direct Chrome DevTools Protocol access for browser automation via a zero-dependency skill or lightweight MCP server, supporting 17 CLI commands across tab management, navigation, interaction, and content extraction. The plugin auto-starts Chrome on a dynamically allocated port, handles JavaScript dialogs and permission prompts transparently, and works across macOS, Linux, and Windows.

Abstract provides meta-skills infrastructure for authoring and evaluating Claude Code plugins, including modular design patterns, hook development frameworks, and quality validation tools. It includes skills like methodology-curator, modular-skills, and skills-eval, plus agents for plugin validation and architecture review.

Cartograph generates architecture, data flow, dependency, call chain, class, and community detection diagrams from codebases by analyzing code structure and rendering visualizations via Mermaid Chart MCP. The plugin provides `/visualize` commands that dispatch a codebase explorer agent to analyze modules and relationships, then synthesize Mermaid diagram syntax for rendering.

Conserve is a Claude Code plugin that optimizes token usage and session efficiency through bloat detection, code quality auditing, and context window management following the Maximum Effective Context Window (MECW) principle. It provides commands for scanning dead code, remediating bloat, auditing AI-generated code patterns, and managing context compression across session boundaries.

Egregore is an autonomous agent orchestrator that manages full development lifecycles through a 16-step pipeline, handling session continuity, token budget management, and crash recovery without human intervention. It coordinates specialist skills (attune, pensive, sanctum, conserve) across work intake, build, quality, and ship phases while persisting state and recovering from failures via a watchdog daemon.

Gauntlet extracts code structure via AST analysis and builds a knowledge graph to generate adaptive coding challenges using spaced repetition, helping developers prevent knowledge atrophy and accelerate onboarding. It supports six challenge types—multiple choice, code completion, trace, explain-why, spot-the-bug, and dependency mapping—with ML-based answer scoring and pre-commit hooks to gate commits behind knowledge checks.

Imbue provides structured analysis methodologies and workflow guards for evidence-backed code review, change analysis, and feature prioritization using RICE/WSJF/Kano scoring frameworks. It enforces best practices through PreToolUse hooks that validate assumptions, prevent package hallucination, gate feature scope creep, and maintain audit trails across git diffs, specifications, and logs.

Memory Palace organizes domain knowledge using spatial mnemonic techniques, building persistent "palaces" and "gardens" with multi-modal search, bidirectional linking, and automatic deduplication. It captures PR review knowledge and intercepts web requests to check local knowledge before external lookups.

Pensive is a reflective code review toolkit for Claude Code that orchestrates domain-specific reviews (Rust, APIs, tests, architecture, blast radius, math, shell scripts) with structured analysis and intelligent skill selection. It identifies code quality issues, security vulnerabilities, and architectural risks through specialized agents, producing actionable findings with severity rankings and remediation steps.

Sanctum automates Git and development workflows through preflight checks, conventional commit generation, PR preparation with quality gates, and version management. It also consolidates documentation, performs scope-focused code reviews, and improves workflows through session analysis and retrospectives.

Tome runs autonomous research across code repositories, community discourse, academic literature, and TRIZ cross-domain analogical reasoning, then synthesizes findings into domain-appropriate reports with adaptive depth and bibliography generation. It integrates with memory-palace for knowledge export and uses GitHub, Hacker News, Lobsters, Reddit, arXiv, and Semantic Scholar as primary research channels.

A token-efficient communication plugin that reduces Claude's output by ~75% while maintaining technical accuracy, optimized for Japanese with features like caveman-style compression, commit generation, and PR review. Includes 3 sub-agents (investigator/builder/reviewer), 6 slash commands, and automatic mode tracking via SessionStart and UserPromptSubmit hooks.

Naksha is a virtual design team plugin that assembles 30 specialist roles (UI designer, UX researcher, content designer, Figma expert, motion designer, and more) for Claude Code and other coding assistants, offering 70 slash commands and 16,000+ lines of design expertise. The plugin activates automatically based on what you're building, integrating design system tokens, component frameworks, accessibility compliance, and multi-channel content creation into your coding workflow.

This plugin implements a two-loop skill pipeline that catches failures during Claude Code sessions through an inner loop of planning, intent-framing, context-surfacing, verification, and self-healing, while an outer loop learns from recurring patterns to promote permanent rules and regression tests. It hooks into session lifecycle and tool-use events to provide active runtime recovery, including automatic remediation when commands, tests, builds, or external services fail mid-task.

This Claude Code plugin provides AI agents with a relational knowledge graph of the Vercel ecosystem and a bundled skill library covering Vercel products, APIs, and workflows for building and deploying web applications. It includes 49 skills, 3 agents, commands, hooks, and an MCP server that integrate with mcp.vercel.com to enable deployment, authentication, caching, and infrastructure management.

Arcgentic is a harness engineering layer that wraps Claude Code and Codex with gated workflows: planning, development, self-audit, optional user testing, external audit, and closeout gates to enforce disciplined multi-round development. It prevents scope drift and lost context by turning ad-hoc prompting into a repeatable engineering process with role-based dispatch, stop states, and evidence collection.

ork is a comprehensive AI development toolkit providing 105 skills and 37 agents alongside 108 hooks and 35 commands for building full-stack applications with Claude Code. It requires only Node.js and integrates deeply into the Claude Code plugin lifecycle via multiple hook events.

Sidequest is a self-hosted Kanban board and orchestration system for Claude Code that persists tasks across context compaction and sessions, automatically routing tickets to executors for verification and review. It provides a local dashboard for planning, tracking, and delivering work with categories, dependencies, and discussion threads that survive chat context shrinking.

Designpowers is a 10-agent design system that runs an inclusive design workflow—discovery, research, strategy, design, build, and review—with accessibility integrated at every step and you as creative director approving or redirecting at each handoff. The plugin works with any AI coding tool via markdown skills and agents, supporting both Direct mode (approval at each step) and Auto mode (full pipeline with end review).

ed3d-basic-agents provides three core agents and two skills for general-purpose tasks that serve as dependencies for other plugins. It runs shell commands during session initialization without requiring external API keys.

This plugin provides a specialized Playwright agent with MCP server integration for automating browser interactions and control workflows. It includes two skills and one MCP server to support best-practice browser automation patterns.

This plugin captures session metadata at startup and provides tools to review Claude Code conversations—analyzing prompting effectiveness, agent performance, and environment gaps through dispatched Opus reviewers that read token-reduced transcripts and write structured findings. For multi-session analysis, it synthesizes cross-session patterns to identify recurring issues and highest-impact recommendations.

Maister provides structured, standards-aware development workflows for Claude Code through 25 agents and 17 skills that enforce best practices and safety guardrails. It includes pre-execution hooks to block destructive commands and shell reminders to keep developers aligned with workflow standards.

Gyoshu is a scientific research agent that orchestrates multi-agent workflows to transform research goals into reproducible Jupyter notebooks with Python execution, data analysis, and verification. It features a Professor agent for planning, a Teaching Assistant for execution, a PhD Reviewer for adversarial verification, and a Grad Student for report generation—all coordinated through persistent Python REPL sessions and checkpoint management.

This Claude Code plugin provides comprehensive tooling for the Bun JavaScript runtime, including 27 skills covering testing, HTTP servers, WebSockets, databases, and framework integrations like Hono, Next.js, and SvelteKit. It includes 6 commands for project initialization, migration, debugging, optimization, and deployment, plus 3 agents for troubleshooting, performance analysis, and Node.js migration.

This plugin generates production-grade Python CLIs for closed-source web applications by automatically capturing and analyzing their HTTP traffic via browser automation. It uses Claude to exercise the app, map its API, and generate agent-ready command-line tools that can be installed and used immediately.

Claude Code plugin providing comprehensive guidance for implementing SEO in Nuxt 3/4 applications using all 8 official Nuxt SEO v5 modules, including robots.txt, sitemaps, Open Graph images, Schema.org structured data, and link checking. Covers installation, configuration, breaking changes, and troubleshooting across core and standalone modules with multi-language support.

Nuxt UI v4 is a production-ready component library with 125+ accessible, Tailwind v4-based UI components, 3 specialized agents, 4 slash commands, and MCP integration for building dashboards, forms, chat interfaces with AI reasoning, editors, and page layouts. The plugin includes pre-built templates for SaaS, documentation, portfolios, and provides deep-dive guides, semantic color theming, and WAI-ARIA compliance built on Reka UI.

Comprehensive Nuxt 4 development plugin with 4 focused skills (core, data, server, production) covering project setup, data fetching, server routes, and deployment, plus 3 diagnostic agents for debugging, migration, and performance optimization. Includes an interactive setup wizard and official Nuxt MCP integration for real-time documentation access.

Nuxt 5 development plugin with 4 focused skills (core, data, server, production), 3 diagnostic agents (debugger, migration, performance), and an interactive setup wizard. Includes official Nuxt MCP server integration for real-time documentation and handles Nuxt 5's major infrastructure changes including Vite 8, Nitro v3, and Web Standard APIs.

Piyaz is a persistent context network that tracks tasks, dependencies, and decisions across coding sessions, allowing developers to maintain project continuity without manual state management. It integrates with app.piyaz.ai and provides 10 agents and 8 skills to help organize and retrieve project context throughout the development lifecycle.

sd0x-dev-flow provides a comprehensive engineering harness for Claude Code with 16 agents and 100 bundled skills that enforce behavior-layer safety gates, pre- and post-tool review hooks, and fail-closed validation anchors. It operates across reminder-layer reviews, structured completion invariants, and risk-scaled audit tiers, while remaining compatible with Codex CLI, Cursor, Windsurf, and Aider via skills-only distribution.

A complete AI-powered patent creation and analysis system that helps inventors search prior art, draft claims, and prepare applications without legal experience through guided workflows and automated validation. It integrates 16 commands, 13 agents, and 17 skills to handle patent rule lookup, prior-art searches across 100+ million patents, document review, and diagram generation entirely within Claude Code with no external MCP server required.

Meridian is an enforcement framework that injects persistent project context, manages planning gates, and learns from sessions to keep Claude Code oriented across long tasks and multiple sessions. It scaffolds a `.meridian/` workspace directory with docs, prompts, and configuration that automatically resurface relevant guidance at key lifecycle moments like session start, tool use, and task completion.

A Claude Code plugin specialized in ADVPL and TLPP for TOTVS Protheus development, offering code generation, ADVPL-to-TLPP migration, error diagnosis, code review with 24 best-practice rules, and automated documentation. It also provides dictionary generation (SX2, SX3, SIX, SXG, SXA, SX1, SX5, SXB, SX7) for functional consultants and supports automatic CP1252 encoding conversion for all ADVPL/TLPP file types.

cc-polymath is a skill management system that organizes 410+ production-ready development skills across 33+ domains into atomic, composable units with progressive discovery via keyword-triggered gateways. It solves context-window efficiency by loading only relevant skills on-demand rather than upfront, reducing startup overhead by 60-84% compared to monolithic knowledge bases.

prd-ce is a PRD lifecycle methodology engine that scaffolds PRD/SoT/EPIC documents to template and drives them toward completion using 4 agents and 50 specialized skills organized by stage. It governs the process with 6 hooks into the Claude Code runtime and deterministic readiness scoring.

A Claude Code plugin delivering 15 best-practices skills and a Flutter reviewer agent for accelerated Dart/Flutter development, including accessibility, animations, testing, BLoC, theming, security, and an autonomous quality-gate loop that drives code to green. The plugin requires the Very Good CLI and Dart toolchain, enforces standards via pre/post hooks, and includes a specialized reviewer agent for security and accessibility auditing.

The VGV AI Flutter Plugin is a Claude Code plugin with 15 best-practices skills covering Flutter and Dart development (accessibility, animations, BLoC, testing, theming, navigation, security, internationalization, layered architecture, license compliance, UI packages, SDK upgrades, and more) plus an autonomous quality-gate loop that drives code analysis, formatting, testing, and coverage to green. It runs locally via bash, dart, and the very_good CLI without requiring API keys or external paid services.

cc10x is a specialized routing harness for Claude Code that distributes requests across eight specialist subagents (build, debug, review, plan, QA, orient, triage, codebase health) with gated workflows, persistent artifacts, and memory preservation. The plugin coordinates multiple agents through hooks and guardrails to ensure fail-closed operation and honest test reporting with fresh-context verification.

This Claude Code plugin automatically maintains CLAUDE.md project memory files as codebases evolve, tracking file edits, deletions, and moves through hooks and updating memory in an isolated agent to preserve context window. It offers zero-config initialization, git-aware syncing, and marker-based updates that preserve manual content while keeping build commands, architecture, and conventions fresh.

The atdd plugin enforces Acceptance Test Driven Development methodology by translating domain-language acceptance criteria into executable Gherkin specifications and generating a project-specific test pipeline with dual acceptance and unit test streams. It integrates with the broader Disciplined Agentic Engineering (DAE) framework to maintain deterministic guardrails and audit trails throughout the feature development lifecycle.

A Claude Code plugin that provides 18 structured workflow skills for guiding AI through design, implementation, code review, testing, and documentation phases. Includes domain-specific profiles (Go, Java, JS/TS, Kotlin, K8s, Python) with checklists, validators, and review rubrics.

NLPM scores, checks, fixes, and tests natural-language artifacts (skills, agents, commands, rules) across Claude Code, Codex CLI, and Antigravity with tier-aware validation and manifest-vs-disk consistency detection. It provides eight slash commands for linting NL artifacts, a standalone Python validator for CI/pre-commit pipelines, and a self-evolving GitHub Actions auditor that harvests teaching examples from clean repos.

codeArbiter is an orchestration layer for Claude Code that routes all intents through gated skills and reviewer agents, mechanically enforces commit and audit-trail gates, and maintains an append-only audit log of all decisions via SMARTS. It requires Python 3 and operates on a per-repo basis, remaining dormant until explicitly activated with `/ca:init`.

Superpowers Optimized is an agentic development framework for Claude Code that adds automatic 3-tier workflow routing, TDD enforcement, 10 proactive safety hooks, and cross-session memory to enforce disciplined coding practices. It features built-in security review with OWASP checklists, adversarial red-teaming, and systematic debugging across 24 specialized skills.

Claudikins Kernel is a disciplined workflow engine for Claude Code that enforces a strict 4-stage pipeline (outline → execute → verify → ship) with gates between each step, preventing shortcuts and ensuring quality through specialized AI agents. Each stage has distinct roles like the taxonomy-extremist researcher, babyclaude implementer, and catastrophiser verifier that work in parallel with shell-based validation hooks to maintain SRE discipline.

HyperGrok transforms Claude into a Hyperliquid trading desk with seven specialist agents (Desk Lead, Market Analyst, Research Analyst, Strategist, Risk Manager, Execution Trader, and Review Officer) and seventeen skills for research, risk management, execution, and review. It starts read-only on public market data and requires user approval for live trading via API wallet integration.

Ultraship is a Claude Code plugin with 45 skills, 13 agents, and 37 audit tools for building, shipping, and scaling production software—covering accessibility (WCAG 2.2), security scanning, code quality, SEO, AI readiness, and bundle analysis. A built-in Currency Guard keeps Claude on current docs rather than stale training data, with a blocking ship-gate scorecard that runs six parallel audits (SEO, accessibility, secrets, code profiling, bundle tracking, env validation) before deployment.

A Claude Code plugin providing interactive onboarding and Q&A skills for mastering Claude Code setup, best practices, automation, and effective workflows. Includes seven skills ranging from interactive guides to introspective development audits and a gamification system that tracks feature usage across sessions.

Agentic-Security automatically scans code for security vulnerabilities (SAST, SCA, secrets detection) using plain-English risk explanations with cost estimates, and can automatically verify and apply fixes before they touch disk. It integrates directly into Claude Code as a plugin or runs standalone via CLI with multiple output formats (HTML, JSON, SARIF, CSV).

motiscope analyzes screen recordings of animations to extract precise timing, easing curves, and keyframes, then generates working code in GSAP, CSS, Framer Motion, or Lottie. The tool runs locally with ffmpeg and Python standard library, requiring no cloud accounts or external services, and works as a Claude Code plugin or portable agent skill.

Context Optimizer monitors Claude API usage, shows real-time costs and token consumption, and automatically routes cheap work to Haiku 5.5 subagents to reduce spending. It provides five reusable skills for chat and Claude Code (fresh-start, doc-digest, project-context, token-check, sharpen-prompt), a live meter displaying context usage and cache countdown, and audit tools to analyze spending patterns across sessions.

Alfred Dev is a software engineering automation plugin that orchestrates the development lifecycle with 10 specialized agents (8 core plus conditional frontend and on-demand agents), persistent project memory, and quality gates across product, architecture, development, QA, security, and deployment phases. It detects project stacks and adapts artifacts to Node.js, Python, Rust, Go, Ruby, Elixir, Java, PHP, C#, and Swift ecosystems with built-in EU compliance (GDPR, NIS2, CRA) and verification gates before each phase transition.

A Claude Code plugin providing three consolidated skills for the complete Agentforce agent lifecycle: authoring agents via Agent Script DSL, testing with safety probes and execution validation, and observability through production session analysis. The plugin integrates LLM-driven safety reviews across development, deployment, testing, and optimization phases.

ALDC is an AI-native development toolkit for Microsoft Dynamics 365 Business Central that provides 5 specialized agents, 10 workflows, and 15 knowledge skills for extension development with test-driven development, architecture reviews, and human-in-the-loop gates. The plugin integrates event-driven architecture patterns, automated code generation, and TDD orchestration through a conductor agent that manages the full spec-to-review cycle.

ALDC is an AI-native development toolkit for Microsoft Dynamics 365 Business Central offering 10 agents, 15 knowledge skills, and TDD-driven workflows for extension-only development with code review, event-driven architecture patterns, and human-in-the-loop gates. It includes specialized agents for architecture, development, test-driven delivery, pre-sales estimation, and agent building, plus MCP servers for AL symbol resolution and documentation lookup.

opentrace-oss is a Claude Code plugin that exposes a knowledge graph for exploring system architecture, code structure, and service dependencies through graph query tools. Once a codebase is indexed, users can ask Claude questions about code structure, dependencies, and architecture using specialized agents like @code-explorer, @dependency-analyzer, and @find-usages.

VGV Wingspan is an AI-native workflow plugin that orchestrates a four-phase development cycle—brainstorm, plan, build, and review—with specialized agents and skills following Very Good Ventures best practices. It integrates code generation, testing, quality review, and PR management into a structured agentic system designed to work alongside the Very Good AI Flutter Plugin for production-grade output.

Superloopy is a lightweight loop harness for Claude Code that orchestrates agents and skills to execute tasks while proving completion with real evidence artifacts stored in `.superloopy/evidence/`. It requires Node.js and supports evidence-backed criteria plus optional subagents, hooks, and specialized skills for research, backend, frontend, and cloning workflows.

A DeepSeek-Claude bridge plugin that enables code review, critique, and task delegation between the two AI models within Claude Code. It provides 10 commands, 1 agent, and 2 skills to coordinate workflows between DeepSeek and Claude using Node.js and local shell execution.

Claude for Financial Advisors provides ready-to-run workflows that help financial professionals gather, organize, and present client data from their firm's existing tools via third-party connectors, while the advisor retains control over recommendations and any system updates. The plugin includes 8 skills for common advisor tasks—onboarding, meeting prep, compliance review, portfolio rebalancing, and estate planning—that pull live data from 25+ connected systems (BlackRock, Addepar, Envestnet, Orion, Wealthbox, and others) and require explicit approval before writing back to external systems.

The ai-literacy-superpowers plugin provides a complete AI engineering and development workflow framework incorporating literate programming, CUPID code review principles, agent orchestration, and three enforcement loops for compound learning. It includes 32 commands, 20 agents, and 41 skills to support engineering practices from development through code review and iteration.

deep-plan transforms vague feature requests into detailed, production-ready implementation plans through AI-assisted research, stakeholder interviews, and multi-LLM review. The plugin orchestrates a comprehensive workflow including research, interview, external LLM review, TDD planning, and section splitting to create isolated, parallelizable implementation units.

Buildomator is a Claude Code plugin that automates structured workflows with planning, execution, and verification phases while keeping project state in an MCP-backed store and minimizing token overhead. It breaks complex work into focused subcontexts with agent skills for research, implementation, and testing, asking you only about design decisions that require human judgment.

Buildomator is a Claude Code plugin that orchestrates project planning, execution, and verification through structured workflows with MCP-backed state management and automatic context resumption. It optimizes token usage (~92% reduction in per-turn overhead) by splitting work into focused subcontexts and asking for human input only on architecture decisions.

A standalone Agent Skill providing CLI reference schemas and wrappers for Beads issue tracking, GitHub, and GitLab operations, plus plan and PRD file format documentation. The skill exposes 5 reference schemas (Beads, GitHub CLI, GitLab CLI, Plan, PRD) across 8 agents and 25 commands for repository and project management workflows.

This plugin integrates PostHog analytics, feature flags, experiments, error tracking, and insights directly into Claude Code through an MCP server, with optional session capture to PostHog LLM Analytics. It provides 27+ tools bundled with 30+ task-specific skills covering HogQL queries, A/B test management, feature flag operations, data warehouse setup, and SDK instrumentation.

claude-brain automatically syncs your Claude Code memory, skills, agents, rules, and settings across all your machines using Git and semantic merge, eliminating the need to re-teach Claude on each device. It runs hooks on session start/end for zero-effort cross-machine knowledge evolution with intelligent conflict resolution.

Grainulator is a research sprint orchestrator for Claude Code that conducts multi-pass investigations with typed claims, evidence tiers, tension detection, and confidence scoring to produce compiled, high-confidence answers in under 60 seconds. It structures research findings as factual, constraint, risk, recommendation, or estimate claims, detects contradictions, and synthesizes results through a 7-pass compiler that grades evidence strength and produces 0-100 confidence scores.

Gangsta is an AI agentic skills framework for spec-driven development that organizes six specialized agents in a mafia-hierarchy model with phases spanning reconnaissance, adversarial brainstorming, formal spec drafting, task decomposition, parallel execution, and delivery. The framework enforces strict governance rules (Omerta), maintains institutional memory via a Family Ledger, and gates every phase with developer approval.

Swarm assembles multi-agent teams (engineers, security reviewers, business stakeholders) to autonomously research, debate, build, and peer-review code tasks until they meet ship-ready standards, then deliver a final PR for your approval. The plugin runs unattended for hours or days, survives interruptions, and uses outcome-framing instead of implementation steps to guide team deliberation toward better solutions.

Livepilot is an agentic production system for Ableton Live 12 that provides 474 tools across 57 domains including device control, Splice integration, spectral analysis, and advanced music theory (neo-Riemannian harmony, species counterpoint, Euclidean rhythm). The plugin includes a Creative Director skill, technique memory, MIDI I/O, and an MCP server for semantic music composition and production workflows.

Pensyve is a persistent memory layer for Claude Code that captures decisions, debugging outcomes, and project context across sessions without explicit invocation. It uses local SQLite-backed embeddings with multi-signal retrieval to proactively ground substantive work in prior lessons while keeping simple commands fast.

ResumeHQ is an AI-powered resume builder that discovers live job listings, scores candidate fit using deterministic engines (not LLM guessing), and auto-tailors resumes with a fail-closed auditing pipeline that refuses to fabricate experience. It produces Workday-compatible DOCX output, generates cover letters, and auto-detects 6+ professional domains while publishing its own scoring benchmarks including failures.

Tyran is a multi-agent orchestration plugin for Claude Code that assigns distinct subagents to different work streams with model tiers matched to task difficulty, maintains a persistent journal and retrospective learning system in your repo, and enforces evidence contracts through pre-execution hooks on tool use, writes, and secrets. It centralizes cost tracking, context management, and decision history on a live dashboard while preventing context sprawl by never letting individual agents accumulate the full transcript of parallel work.

ThreatSwarm is an offensive security workspace for Claude Code with 27 specialist agents covering recon, exploitation, and post-exploitation, plus scope enforcement and evidence logging for penetration testing and red-team operations. It provides six engagement commands (engage, attack, pwned, hunt, ir, report) and three hook-based controls that gate tool execution by scope, log all commands, and aggregate findings.

code-graph-mcp auto-indexes your codebase as an AST knowledge graph to enable semantic search, call graph traversal, HTTP route tracing, and impact analysis through MCP tools. The plugin hooks on SessionStart to initialize and expose these code navigation capabilities via an integrated agent.

Akii is a free SEO, AEO (Answer Engine Optimization), and GEO toolkit that audits websites, optimizes pages, generates schema markup, clusters keywords, and tracks AI visibility across ChatGPT, Claude, Gemini, Perplexity, Copilot, and Google AI Overviews. The plugin includes 15 skills, 5 autonomous agents, and 8 commands for content strategy, technical audits, and multi-language localization—with optional integration of Ahrefs, GSC, Apify, and DataForSEO MCPs for richer data.

HCF orchestrates autonomous parallel development by separating interactive planning from fully autonomous TDD execution, using a 3-agent architecture with 4 skills to implement features with test-driven development and dependency resolution. The plugin coordinates multi-worker batches across hook points (pre-plan, post-plan, pre/post-implementation, pre/post-batch, pre/post-commit) and maintains all state in plan files for resumable, context-aware runs.

Optimus sets up your Claude Code project with AI-optimized CLAUDE.md files, coding guidelines, formatter hooks, and built-in quality agents (code review, refactoring, TDD, test coverage) learned from your actual codebase. It runs 19 skills that establish project context and enforce code quality standards across Red-Green-Refactor cycles, deep-fix loops, and resumable testing workflows.

An always-on Claude Code agent that runs locally on your machine or server, accessible from the terminal, Claude app, Discord, Telegram, or custom channels. It maintains ongoing responsibilities like system monitoring and research routines, carries progress across sessions, and proactively surfaces work that needs attention.

claude-code-hermit is a personal always-on AI assistant that lives in your project with memory-driven learning, autonomous task execution, and self-improvement through experience reflection. It runs 24/7 via Docker or tmux, handles crash recovery, executes background routines, and learns from patterns to propose operational improvements.

Turns Claude Code into a 24/7 home automation agent for Home Assistant, providing read-first monitoring, safety-gated automation drafting and structural management, and daily/weekly health routines. Integrates with the official Home Assistant MCP Server and REST API, gating every actuation with a fail-closed safety hook and requiring explicit approval before applying changes.

A feed-to-brief pipeline that fetches, scores, and synthesizes curated news from your chosen sources on a schedule, with story tracking and weekly summaries. It includes source curation tools, a validation system for feed registries, and security controls to prevent fetches from untrusted domains.

Hermitd is an always-on Claude Code agent that runs locally on your machine or server, accessible via the Claude app, Discord, Telegram, or custom channels, with proactive task monitoring, persistent state, and scheduled routines. It integrates with your Claude subscription and can be extended with custom MCP servers, skills, and plugins for continuous knowledge maintenance and system monitoring.

A feed-to-brief pipeline that fetches, scores, and synthesizes curated news briefs from your chosen sources on a schedule, with story tracking and weekly performance analytics. It runs a 7-phase processing workflow (fetch, score, write, deliver, archive, synthesize) backed by source-quality audits and a fetch-guard security hook.

This plugin transforms Claude Code into a 24/7 Home Assistant management agent that learns your house layout, monitors device health, and drafts automations while blocking unsafe actions by default. It integrates with Home Assistant's official MCP Server and REST API, running routines for pattern detection, security audits, and integration monitoring—all changes require your approval before execution.

devpace is an AI-native development harness for Claude Code that enforces goal-to-code traceability, automated quality gates, impact analysis for requirement changes, and cross-session continuity through multi-role collaboration and comprehensive hooks. It manages the full development lifecycle from business goals through requirements to code changes, with automatic context restoration between sessions and human-approval-required quality gates that cannot be bypassed.

Tonone is an open-source Claude Code plugin that bundles 100 AI specialists across engineering, product, operations, legal, design, data science, security, developer experience, infrastructure, and AI operations — each with deep domain expertise in their field. Users invoke specialists via commands like /apex-plan or /forge-infra to get production-ready work across the full software development lifecycle without external paid services.

Claude Universe provides five integrated systems—Navigate, Diagnose, Shield, Survey, and Timewarp—that enable systematic code analysis for PR readiness, test authoring, security review, architecture tracing, and code evolution detection. It combines 6 MCP servers for deterministic pattern matching and dependency analysis with 20 Claude-guided commands and 6 autonomous agents that work across any language.

This Claude Code plugin provides a comprehensive toolkit for creating, validating, and distributing Claude Code plugins, featuring slash commands for scaffolding, a reviewer agent for audits, and ambient guidance via a skill component. It includes 7 commands, 1 agent, 1 skill, and 3 automation hooks (PreToolUse, PostToolUse, SessionStart) to enforce validation guardrails throughout the plugin development workflow.

Craft is a Claude Code plugin that enforces a read-only codebase by default, routing all changes through a Write Gate as planned work, while maintaining a local history of project decisions and design tokens that help Claude learn your architectural preferences over time. It ships with 62 commands, 27 agents, 11 skills, and a dashboard that visualizes your project's evolution as an interactive galaxy of interconnected work.

archcore is a Claude Code plugin that enforces your project's architecture, rules, and decisions during AI-assisted coding by injecting context through session hooks and tool-use events. It uses 4 commands, 2 agents, and 4 skills to guide code generation while maintaining compliance with your project's architectural standards.

Claude Code on Steroids extends Claude Code with 24 production-grade skills across discipline, domain expertise, intelligence, coordination, and execution layers—built on obra/superpowers with 10 new skills, token burn optimization, and update-proof overrides. The plugin includes pre-verification for APIs, multi-agent templates, skill chain recipes, domain trigger mappings, and a /tokenburn CLI for cost analytics, reducing typical debugging token spend by 60–99%.

claude-leverage is an AI-coding-agent suite for Claude Code and Codex CLI that enforces security hooks, self-maintaining conventions, and cross-tool skills to keep repositories safe for sustained agent-driven development. It provides 16 skills, 3 subagents, and 9 deterministic security hooks that automate repo maintenance, surface context at edit time, and block dangerous operations before they happen.

Tool Executor is a configurable MCP wrapper that consolidates 96 tools from 7 example servers into 3 discoverable commands (search_tools, get_tool_schema, execute_code) with semantic search and sandboxed TypeScript execution. It reduces token consumption by 97% through lazy loading and batched execution, bridging the gap between the API's programmatic tool calling and Claude Code's serial execution model.

SuperClaude for SAP (sc4sap) is a Claude Code plugin providing 28 specialized agents and 17 workflow skills for end-to-end SAP ABAP development, connecting directly to SAP systems via MCP to create, analyze, and manage ABAP objects with multi-environment profiles and built-in security controls. It supports SAP ECC, S/4HANA On-Premise, and S/4HANA Cloud with Clean ABAP review, program generation with Phase 4/6 hardening, package-to-process business documentation, and 14-module consultation across retail, automotive, pharma, and other industries.

Shipyard is a Claude Code plugin that orchestrates the full software project lifecycle—from brainstorming and planning through parallel-agent building, code review, security audits, and shipping. It integrates spec-kit for spec-driven development, runs test-driven builds with quality gates, and provides state management via shell hooks.

Arxitect is an agentic coding plugin that enforces best-practice software design and architecture by providing specialized reviewers that validate API Design, Object-Oriented Design, and Clean Architecture standards. It includes implementation agents and review skills that help coding agents build robust, maintainable software while reducing context burn and improving code quality.

The divi5-toolkit is a Claude Code plugin that assists Divi 5 developers with CSS validation, code generation, accessibility auditing, and performance optimization for Core Web Vitals. It provides 10 commands, 5 agents, and 3 skills including setup auto-detection, selector lookup, and project health diagnostics across the latest Divi 5.13 modules and features.

archcore enables spec-driven development and context engineering for AI coding agents by leveraging project context from Git repositories and managing tool execution through pre/post-use hooks. It provides 4 commands and 2 agents to help structure and validate AI-driven code generation workflows.

archcore enables spec-driven development for AI coding agents by using project context stored in Git to generate and enforce architectural specifications. The plugin provides commands, agents, and skills that hook into the tool-use lifecycle and session initialization to guide code generation toward architectural consistency.

This Agent Skill provides comprehensive reference documentation for Apple's xcrun developer tool ecosystem, covering xcodebuild, swift build, simulator management, device deployment, code signing, and binary inspection. A paired Subagent executes builds, tests, and deployments for Swift packages and Xcode projects while delegating complex command construction questions to the Skill.

Nimble provides live web search, scraping, and data extraction capabilities for AI agents through 15 reusable skills organized into business research, marketing, SEO, healthcare, and productivity workflows. The plugin includes Web Search Agents for open-ended research with citations and Extraction Templates for structured data collection from known websites.

PagoKit picks the optimal payment provider for your project and auto-generates a complete, secure integration including checkout, webhooks, database schema, and customer portal, backed by deterministic validators that block insecure writes at tool-use time. It knows 42 providers, 136 payment methods, 74 countries, and 106 currencies with their correct exponents, verifying webhook signatures and refund feasibility locally with no external accounts or telemetry.

Forge is a native Claude Code plugin that automates spec-driven development through a five-phase autonomous loop: brainstorming acceptance criteria, planning task DAGs, executing tests-first in parallel git worktrees, reviewing and verifying code, and backpropagating spec gaps. State persists on disk in .forge/ to survive context resets and crashes, allowing a single one-line idea to produce reviewed, tested, and committed code without manual intervention.

LegalRabbit DOCX enables Claude to read, create, and edit DOCX files locally with tracked changes and comments, using 2-5x fewer tokens than alternatives. The plugin works completely offline to ensure data privacy and integrates seamlessly with Claude for Legal workflows.

This plugin integrates the ase (Agentic Software Engineering) tool into Claude Code, enabling 10 agents and 54 skills for automated software engineering tasks. It provides hooks into the development lifecycle (pre-tool use, session management, user prompts) and includes shell execution capabilities.

The /deep-implement plugin orchestrates a disciplined implementation workflow that takes section files from /deep-plan and builds them with test-driven development, integrated code review, and structured git commits. It automates the execution cycle of writing tests first, implementing code, running code review, gathering user feedback, and committing changes atomically.

Harness Evolver autonomously improves LLM agent codebases by evolving prompts, routing, tools, and architecture using multi-agent proposers, LangSmith experiments, and git worktrees. Self-organizing agents iteratively propose, evaluate, and merge improvements while gatekeeping regressions and tracking evolution memory.

Session Orchestrator manages structured development sessions with wave-based planning, VCS integration, inter-wave quality gates, and session persistence across Claude Code, Codex CLI, and Cursor IDE. It enforces design-code alignment, ecosystem health monitoring, and safety checks via hooks while collecting cross-session metrics for adaptive workflow optimization.

Evolving Lite is a self-improving Claude Code plugin that captures user corrections as learned experiences and injects matching context before future tool calls, with built-in safety guardrails including self-tuning delegation config, progressive activation across sessions, and automated health monitoring. It uses bash for execution and Kairn as a prerequisite memory layer, actively learning from repeated corrections while preventing config drift through loss-fast trust models and no-regression guards.

Markifact is a universal marketing automation plugin that connects Claude to 50+ platforms including Google Ads, Meta Ads, GA4, Shopify, HubSpot, and more, enabling 1000+ operations for campaign management, auditing, and optimization with human-in-the-loop approval on all writes. It provides pre-built workflows (slash commands) and skills for creating campaigns, rotating creative, diagnosing underperformers, and pulling performance data across paid media, analytics, organic social, e-commerce, CRM, and messaging platforms.

claude-mods is a Claude Code plugin providing 108 skills, 3 agents, 7 commands, and 6 hooks for modern development workflows, with executable tooling for React, Rust, PostgreSQL, Cloudflare Workers, and Next.js backed by test suites and staleness verifiers. It implements the Agent Skills specification and Anthropic's patterns for long-running agents, installing as a standard plugin with no external API key dependencies.

assets-pack is a cross-vendor IT asset lifecycle management workflow that tracks warranty status, flags end-of-life/end-of-support devices, and plans hardware refresh cycles by aggregating device data from connected RMM platforms (Datto, NinjaOne, N-central, Kaseya VSA, ConnectWise Automate, Atera, SuperOps, Syncro, Action1, ImmyBot) and documentation tools (IT Glue, Hudu). It delivers portfolio-wide or per-client visibility into warranty expiration, OS/firmware support timelines, and tiered refresh calendars without requiring all platforms to be connected.

This cross-vendor security awareness plugin tracks training completion, phishing simulation results, and per-user risk scoring across connected awareness platforms like KnowBe4, Proofpoint, and Checkpoint Avanan through Conduit. It complements incident response with human-layer prevention, measuring training gaps and behavioral risk before incidents occur.

backup-pack bundles job health monitoring, restore-test verification, retention/RPO compliance, and DR readiness checks across connected backup and BCDR tools (Datto BCDR, Datto SaaS Protection, Spanning, Unitrends) via the WYRE MCP Gateway. It provides three independent skills and agents that discover what's actually connected and distinguish missed backups from failures, rank restore evidence, and flag retention/RPO gaps against contracts.

Cross-vendor network and cloud infrastructure operations pack that monitors device health, detects capacity issues, and identifies cost anomalies across Auvik, Meraki, Domotz, Azure, and DigitalOcean connections. It normalizes findings across different vendor models and operates through the WYRE MCP Gateway (Conduit), discovering connected tools at runtime and reporting what can be verified.

This Claude Code plugin maps live tenant configuration from M365, infrastructure tools, and documentation systems to compliance control frameworks (CIS, SOC 2, HIPAA) and detects unauthorized configuration drift, degrading gracefully when connectors are unavailable. It provides source-cited evidence packages, drift reports prioritized by risk, and pre-fills cyber-insurance questionnaires using live data from CIPP, Liongard, IT Glue, Hudu, and EDR platforms via the Conduit gateway.

Bundles judgment and workflow for on-call handoffs, blameless postmortems, and error-budget tracking across any combination of incident-management and observability tools connected through the WYRE MCP Gateway. Discovers and adapts to whatever incident-management (Rootly, PagerDuty, BetterStack), observability (Sentry, Datadog, Grafana), and platform/deploy tools (GitHub, Cloudflare, Vercel, Netlify, Supabase, Neon) are actually connected, never hardcoding vendor APIs.

This plugin reconciles billing across multiple vendors by matching PSA contracts against accounting invoices and cloud-marketplace subscriptions, identifying license true-up gaps and client profitability rankings. It dynamically discovers which PSA (Autotask, HaloPSA, ConnectWise, or Syncro), accounting platform (QuickBooks Online or Xero), and optional marketplace distribution tools (Pax8 or Sherweb) are connected via the WYRE Conduit gateway, ensuring vendor-agnostic operation across organizations.

The ncentral plugin enables MSP technicians to manage N-able N-central RMM infrastructure directly from Claude, providing device inventory, issue triage, task status, and organizational property management across customer endpoints. All API calls route through Conduit, eliminating the need for local credentials or SDKs.

The ops-pack provides cross-vendor service-desk operations including board health auditing, dispatch prioritization, SLA monitoring, and shift handoffs by dynamically connecting to any PSA (Autotask, HaloPSA, ConnectWise, Syncro, Kaseya BMS) and optionally RMM or on-call tools through the WYRE Conduit MCP gateway. It bundles judgment logic for escalation decisions, dispatch scoring, and ticket hygiene on top of the connected PSA's native data without hardcoding vendor-specific APIs.

Sales-pack bundles cross-vendor sales judgment — stall diagnosis, lead scoring, follow-up drafting — on top of whatever CRM, proposal, quoting, and scheduling tools are connected through Conduit. It tracks pipeline health, quote-to-close handoffs, and warm-lead routing without assuming a fixed vendor stack, degrading gracefully when connectors are missing.

This Claude Code plugin normalizes security alerts across heterogeneous EDR/MDR/SIEM vendor stacks and runs triage playbooks, assembling incident timelines without vendor lock-in by discovering connected tools at runtime. It's designed for MSPs managing multiple clients with partial coverage of security tools, explicitly reporting what it can and cannot verify.

This plugin implements a self-improving loop for Cowork (cloud container) environments by distilling Claude's experiences into reusable skills and persisting them to claude.ai via SendUserFile, while avoiding SessionStart hook race conditions and ephemeral container storage through UserPromptSubmit guidance and Post-Turn distillation triggers. It is a Cowork-specific variant of claude-code-self-improving-skills that replaces curator functionality with direct skill export to claude.ai's skill management system.

wigtn-plugins is an AI-native development plugin with 11 agents, 6 commands, and 7 skills for rapid end-to-end design-to-deployment workflows. It includes team-based parallel build capabilities, screen specification generation (IA/User Flow/Wireframe HTML), and WIGTN-brand PowerPoint generation across 20 design styles.

Groundwork is a comprehensive skills library for Claude Code containing 41 skills, 18 agents, and 5 hooks that consolidate proven techniques for planning, design, test-driven development, debugging, and collaboration. It integrates with bash and Node.js to enable workflows spanning from requirements gathering through implementation, code review, and quality verification.

BetterCallClaude is a Swiss legal intelligence plugin that integrates BGE/ATF/DTF precedent research, case strategy, legal drafting, and citation verification for all 26 Swiss cantons with built-in Anwaltsgeheimnis privacy protection. It provides 27 commands across 21 agents for legal research, litigation strategy, document analysis, and multi-language legal translation (German, French, Italian, English).

This plugin provides full API lifecycle management within Claude Code, including collection syncing, client code generation, API discovery, testing, mock servers, documentation, and security audits—all powered by the Postman MCP Server. It includes an agent that analyzes APIs for AI agent readiness across 8 pillars and covers OWASP Top 10 security checks.

Compound V is a multi-model coding orchestrator for Claude Code that sizes feature requests, partitions them across isolated worktrees, and routes work to Claude, Codex, Cursor, and Antigravity workers based on complexity — planning with Opus, reviewing with parallel pre-flights (code archaeology, domain expertise, library validation), and gating writes through scope enforcement. It intercepts brainstorm-to-execution transitions with recon passes, maintains project-local memory over documentation, and supports epic mode for multi-feature builds with crash-resumable runs and adaptive tier-based routing.

Craftsman enforces software engineering discipline across Claude's development workflow through a rules engine, correction learning system, and real-time quality gates that apply identically in hooks and CI. It integrates domain-driven design, clean architecture, and test-driven development practices using multi-level rule inheritance, metrics tracking, and structural ratcheting to prevent architectural decay.

dev-flow integrates code review, automated fixes, commits, and linting directly into Claude's development workflow through pre- and post-tool hooks that validate and process changes. It runs shell commands (bash, node, python3) at key lifecycle points to enforce coding standards and gate development actions.

Whetstone is an AI-powered development plugin with 18 agents, 22 commands, 32 skills, and 1 MCP server that automate code review, research, design, and workflow tasks across multiple programming stacks. It includes specialized agents for accessibility, security, performance, cloud architecture, database validation, Figma design sync, and deployment verification, with commands ranging from autonomous full-stack engineering (`/ia-lfg`) to targeted verification and documentation workflows.

This Claude Code plugin connects to Fullstory's behavioral analytics platform to answer product questions about user sessions, drop-offs, and conversion funnels without writing SQL or exporting CSVs. It includes 46 skills covering analytics, investigation, segmentation, and debugging, all triggered automatically based on your natural-language question.

memory-kit provides persistent, managed memory for Claude agents as plain markdown files stored in your repository, with automatic injection at session start, pre-compaction guards, and lazy-loaded skills for memory auditing, session review, QA, and code synchronization. It operates through four hook events and includes four specialized agents (executor, recon, idea-validator, qa) plus ten skills—all governed by configurable size caps to keep memory focused and within budget.

claude-english-buddy automatically corrects English grammar and typos in your prompts before Claude sees them, restoring a feedback loop that helps non-native speakers improve over time. It also translates non-English input, refines prompts with a :: prefix, and tracks your error patterns and improvement trajectory through daily and long-term analytics.

Brewcode is a Claude Code authoring toolkit providing skill, agent, and rule creation with semantic code search, project conventions, E2E tests, and generated team-based code review. It maintains task context across Claude Code's compaction cycles through hooks and supplies 9 skills and 5 agents for managing development workflows, conventions, and specialized review processes.

Brewtools is a Claude Code plugin providing text optimization/humanization, secrets scanning, SSH and GitHub Actions deployment, subagent governance guards (deadline/return-size/routing), task board, context measurement, and plugin management—all without external API keys. It includes 13 skills and 3 agents with hardened delegation controls via per-binary allowlists and approval gates for destructive operations.

Claude Architect is a Claude Code plugin that delegates coding tasks to isolated producer agents (Codex, OpenCode, Pi, Pythinker, Antigravity CLI, or headless Claude) in detached Git worktrees, then independently verifies and reviews their work before human-controlled integration. It enforces isolation, evidence-based verification, and separated authority—the host Claude reviews and decides on frozen candidate artifacts without the producer being able to approve its own changes.

Oh-my-obsidian connects Claude Code to an Obsidian vault to provide persistent project memory across sessions, auto-recording decisions and instantly recalling context through Markdown-backed search. The plugin includes guided setup, session-save automation, vault refactoring, and optional Git sync to keep your knowledge base organized and searchable.

TwinCAT-Agent automates PLC development for Beckhoff IEC 61131-3 using a dedicated agent with strict Structured Text rules, naming conventions, and syntax validation. It integrates local TwinCAT XAE automation and remote Beckhoff InfoSys documentation lookup via two MCP servers.

cix is a semantic code search client for Claude Code that requires a self-hosted cix (CodeIndeX) server and provides slash commands, a bundled CLI, skills for single and cross-project workflows, and behavioral hooks that suggest cix over grep for indexed codebases. The plugin ships with eight slash commands, an experimental workspace skill for multi-repo tasks, and a sub-agent for parallel per-repo investigation with intelligent caching to minimize context overhead.

Gnosis MCP is a zero-config knowledge base server that indexes local documentation (Markdown, git history, crawled websites) and serves semantic+keyword hybrid search to Claude via MCP, typically reducing token consumption 5–10× per lookup. It stores data locally in SQLite by default or PostgreSQL at scale, with no cloud dependencies or API keys required.

This Claude Code plugin scaffolds Mercado Pago payment integrations (Checkout Pro, Checkout API, Bricks, QR, Point, Subscriptions, Marketplace, Wallet Connect, Payouts, SmartApps) via an orchestrator agent with four specialized skills: mp-integrate (wizard), mp-webhooks (HMAC validation), mp-test-setup (test credentials), and mp-review (security audits). Scaffolding works offline using bundled contracts; live operations like credential import and webhook registration connect on demand via the official Mercado Pago MCP server without requiring upfront API key setup.

React Native HiFi provides a comprehensive agent workflow for React Native and Expo development, featuring 39 skills that guide agents through design refinement, TDD-driven implementation plans, subagent-driven development, and specialized patterns for native UI, testing, and debugging. It integrates production-grade techniques from Software Mansion and Callstack, emphasizing red/green TDD, code review workflows, and autonomous multi-agent collaboration for extended development sessions.

fuse-ai-pilot is a collection of specialized workflow agents including sniper (code quality), research-expert, explore-codebase, and websearch that implement the APEX methodology (Analyze → Plan → Execute → eXamine) with framework-specific reference auto-detection for Laravel, Next.js, React, and Swift. The plugin provides 9 agents across 17 skills organized by domain (code-quality, research, seo, exploration) and connects via PostToolUse/PreToolUse hooks while running shell commands.

fuse-cartographer generates indented markdown maps of the Claude Code plugin ecosystem to help agents navigate and discover available tools and skills. It provides ecosystem visualization through shell-executed commands triggered by session start and tool use events.

This Claude Code plugin monitors Claude updates by tracking changelog entries, detecting breaking changes, and analyzing community sentiment through Exa search integration. It provides plugin compatibility analysis and real-time notifications via post-tool-use hooks to keep developers informed of relevant updates.

A design director plugin that generates production-ready UI/UX for marketing websites, web apps, iOS, and Android—producing HTML/CSS directly for web targets and device-framed mockups plus handoff specs for mobile. Enforces a rigorous design method covering briefs, signature elements, anti-AI-slop principles, design systems with OKLCH tokens, motion profiles, UX copy, and a deterministic review gate aligned with WCAG 2.2.

Provides expert Go 1.26+ development guidance with 1 agent and 5 skills covering idioms, concurrency, testing, tooling, and backend services, all adhering to SOLID principles and golangci-lint v2 standards. Activates automatically in Go projects with a go.mod file and requires bun as an external tool.

The fuse-laravel plugin is an expert Laravel 13 development assistant offering 23 specialized skills covering architecture, ORM, APIs, authentication, testing, queues, Livewire, templates, migrations, and billing with PHP 8.3+ and SOLID principles. It provides comprehensive documentation and PHP Attributes-first patterns, activated by keywords like Laravel, Eloquent, Blade, Livewire, and common development tasks.

This Claude Code plugin provides an expert Next.js 16 developer agent with 11 specialized skills covering App Router, Server Components, Prisma 7 ORM, Better Auth authentication, TanStack Form, Zustand state management, and shadcn/ui components. It automatically activates when working in Next.js projects and guides modular architecture using SOLID principles.

The fuse-php plugin provides an expert agent and six specialized skills for modern framework-agnostic PHP development (PHP 8.5/8.4), covering libraries, Symfony components, Slim apps, and CLI tools with PER Coding Style 3.0, PHPStan static analysis, and SOLID principles. It activates automatically when a composer.json is present without an artisan file, deliberately excluding Laravel projects which are handled by the fuse-laravel plugin.

fuse-react is a Claude Code plugin offering an expert React 19 developer agent with skills for modern React patterns (React 19 hooks, TanStack Router/Form), state management (Zustand, Jotai), component frameworks (shadcn/ui), testing (Vitest, Testing Library), and internationalization (react-i18next), all built around SOLID principles and modular architecture. It activates automatically when working with React projects and provides guidance on file-based routing, type-safe forms with Zod validation, and comprehensive testing practices.

fuse-rust is an expert Rust 1.96+ (2024 edition) agent with 7 skills covering ownership, error handling, async/tokio, axum backends, testing, tooling, and ecosystem crate selection. The agent activates in projects with Cargo.toml and enforces clippy-clean, SOLID-principled code practices.

The fuse-security plugin detects and remediates security vulnerabilities including OWASP Top 10 issues, SAST scanning results, CVE risks, dependency problems, and exposed secrets. It integrates shell execution and tool hooks to audit code and dependencies in real-time.

fuse-seo provides technical SEO, schema markup, E-E-A-T validation, AI Overviews optimization, and local SEO capabilities as a local-first Claude Code plugin with framework awareness and zero third-party API dependencies. It covers sitemaps, hreflang, internal linking, content briefs, semantic clustering, and search experience optimization through 9 agents and 21 skills.

fuse-shadcn-ui is a Claude Code plugin that analyzes and assists with shadcn/ui components, Radix UI, Base UI detection, and component patterns through five specialized skills and two hooks for pre/post tool use. It supports theming configuration and migration scenarios for component library integration, requiring bun as an external dependency.

fuse-solid enforces SOLID principles across multi-language projects through automatic project detection and validation via an integrated agent. It integrates hooks into the development workflow to check code patterns before and after tool use, plus at session start.

Expert Swift 6 and SwiftUI development plugin covering all Apple platforms with specialized skills for architecture, concurrency, data persistence, and testing. The plugin includes an intelligent agent that activates relevant expertise when you mention iOS development, navigation patterns, async/await, performance optimization, or platform-specific features.

A Claude Code plugin providing expert guidance on Tailwind CSS v4.1 with CSS-native configuration, custom directives (@theme, @utility, @variant), and the faster Oxide engine. It includes 16 specialized skills covering layout, styling, utilities, responsive design, and new v4.1 features like OKLCH colors and container queries.

This Claude Code plugin provides an expert TanStack Start full-stack developer agent with 9 specialized skills covering file-based routing, server functions via createServerFn, middleware, server routes, authentication, and Nitro deployment. The agent auto-activates when a TanStack Start project is detected (via @tanstack/react-start and tanstackStart() Vite plugin) and guides developers through framework fundamentals, selective SSR, and isomorphic execution patterns.

The fuse-typescript plugin is a Claude Code agent that provides expert guidance for pure TypeScript projects targeting TypeScript 6.0, Node 24 LTS, or Bun 1.3, with skills covering configuration, language patterns, runtime features, linting, testing, and packaging. It activates automatically for TypeScript projects without framework configs and enforces SOLID principles through strict typing, ESM-first packaging, and modular architecture.

This Claude Code plugin provides 11 skills, 2 agents, and 1 command for querying and analyzing Honeycomb observability data, including production investigations, SLO tracking, and OpenTelemetry instrumentation guidance. It integrates with the Honeycomb MCP server to enable workflow automation around pattern detection, incident analysis, and Beeline migration tasks.

Praxis is a reasoning methodology plugin that classifies problems, routes them to appropriate cognitive frameworks, and validates designs before execution by enforcing structured decision gates and checklists. It provides 18 specialized skills covering intent alignment, security reasoning, diagnostic analysis, code quality, architecture decisions, and strategic planning to ensure agents think deeply before taking action.

This plugin enables developers to build and deploy Prismatic custom components, Code Native Integrations, and embedded marketplace experiences directly from Claude. It provides commands, agents, and skills for managing the full development lifecycle of Prismatic integrations using Node.js and npm.

Sage is a skills framework that guides AI agents through a structured process (UNDERSTAND → ENVISION → DELIVER → REFLECT) with 5 agent personas, 53 skills, and deterministic verification gates to ensure quality outcomes. It layers instructions smartly, detects knowledge gaps before implementation, and maintains session state across interruptions with persistent memory.

singularity-claude automatically creates, scores, repairs, and hardens Claude Code skills through recursive feedback loops that evolve skills based on execution performance. Skills progress through maturity stages (draft → tested → hardened) and are locked as production-grade once they achieve high scores across multiple runs.

Ucai is a Claude Code plugin that implements an 8-phase build workflow with native architecture components: commands, agents, skills, and hooks for enforcing structured development with pre-flight audits, deterministic phase enforcement, and persistent task tracking. It replaces external frameworks by mapping directly to Claude Code's native systems and includes author/reviewer separation for tests, multi-agent code review, and autonomous spec-to-PR pipelines with zero approval gates.

This Claude Code plugin enforces quality gates for 1C:Enterprise (BSL) development by blocking session completion until code-quality checks pass, analyzing changes across three axes (volume, code archetypes, complexity) to determine review depth. It produces human-readable findings and machine-readable evidence trails showing what was checked, what was skipped, and coverage across static analysis, development standards, SOLID/GRASP architecture, metadata XML integrity, and file hygiene.

fable-baton routes routine development work from Fable 5 to tiered subagents (Opus, Sonnet, Haiku) based on task complexity, preserving Fable's tokens for judgment and orchestration. A SessionStart hook injects orchestration policy, a UserPromptSubmit reminder re-asserts delegation rules, and a PostToolUse counter enforces routing when consecutive inline tool calls exceed a threshold.

This Claude Code plugin streams background music across lofi, jazz, classical, ambient, electronic, and other genres directly into your coding sessions, with an AI DJ that learns your preferences and automatically selects music based on what you're working on. It integrates with your session lifecycle via shell hooks, supports multiple platforms (macOS, Linux, Windows, WSL2), and includes a focus timer with pomodoro sessions.

claude-music provides background music streaming with multiple genres (lofi, jazz, classical, ambient, electronic, synthwave, lounge, indie) directly within Claude Code sessions. An AI DJ (DJ Ken) automatically selects music based on coding activity and user preferences, with commands to control playback and customize the listening experience.

Galyarder Framework is an open-source agent operating system that routes high-level business intent through 45 specialized agents, 157 skills, and 25 commands to produce governed, verified execution across engineering, marketing, product, security, legal, and finance domains. It bridges strategy to implementation via structured intent intake, department routing, blueprinting, specialist execution, operational auditing, and artifact generation—with built-in review gates, audit trails, and human-directed control throughout.

This Claude Code plugin provides 21 commands, 29 agents, and 15 skills to streamline AI-assisted development workflows with session management and task verification. It integrates shell-based utilities for session multiplexing, todo persistence, and deliverable validation across tool use and session lifecycle events.

Crewforth provides disciplined agents and skills for Claude Code with tool-level gate hooks that enforce commit/push approval, guard destructive operations, and measure context usage. It includes git commit trace, secret, and bloat scanning through bash integration and session rehydration capabilities.

idiolect provides 62 fully-specified human voice profiles and a deterministic AI-tell scanner to write, humanize, and audit social posts that read as distinct, genuine people verified by stylometry. The plugin includes a conformance checker, semantic auditor, and verify-revise loop that remove AI tells while maintaining individual voice characteristics across platforms like Reddit, HN, LinkedIn, Facebook, and X.

A multi-agent autonomous development framework that transforms tickets into pull requests, orchestrating specialized agents (Opus, Sonnet, Haiku) for triage, backend, frontend, database, DevOps, code review, QA, and security tasks in parallel. Installs as a CLI tool or Claude Code plugin and supports both interactive and autonomous modes, with optional VPS pipeline integration via the Just Ship Board.

This plugin assesses your current cloud infrastructure and billing on GCP or Heroku, then generates production-ready Terraform, migration scripts, and cost comparisons to recommend whether AWS migration makes sense. It also detects AI/agentic workloads and recommends specific Bedrock migration paths with real-time pricing data and framework-specific gotchas.

The Opik plugin automatically traces Claude Code sessions and nested agent calls to Opik, an open-source LLM observability platform by Comet, capturing tool use, thoughts, and responses as spans. It provides built-in skills for instrumentation, diagnosis, testing, evaluation, and optimization of AI applications, with support for frameworks like OpenAI, Anthropic, LangChain, and CrewAI.

This plugin integrates Claude with X, LinkedIn, Reddit, and YouTube through the Socials browser extension, enabling users to post, engage, search, and manage content on these platforms directly from Claude Code. It provides 7 commands and 4 agents to automate social media workflows including browsing, scrolling, and interaction.

The socials Claude Code plugin connects Claude to X, LinkedIn, Reddit, and YouTube through the Socials browser extension, enabling posting, engagement, searching, and management of social media content directly from Claude Code. It provides 4 agents, 4 skills, and 7 commands for automating social media workflows across multiple platforms.

This Claude Code plugin enforces mandatory AI workflows and performs intelligent codebase graph analysis by combining the superpowers methodology with AST-based code-review-graph analysis across Node.js, Flutter, and PHP projects. It provides graph-based tools for impact analysis, architectural visualization, and code quality review integrated into a TDD-driven workflow with planning, execution, and merge gates.

Media OS is a comprehensive Claude Code plugin routing natural-language media production requests to 96 specialized skills across FFmpeg transcoding, HDR mastering, live streaming, broadcast tools (NDI, DeckLink, Dolby Vision), AI media processing, and OBS automation. It combines strict OSI-open AI model licensing, deterministic routed dispatch, safety hooks, and CLI toolbelt integration to handle production-grade workflows from video encoding and color grading to lipsync and PTZ camera control.

RocketSmith is an end-to-end model-rocket toolchain that orchestrates OpenRocket (flight simulation), build123d (parametric CAD), and PrusaSlicer (FDM slicing) to let agents design, simulate, and build rockets. It closes the loop by feeding real printed-part weights back into the simulation for post-build stability verification.

The encode-toolkit plugin provides 20 ENCODE API tools and 47 expert skills for genomics research, enabling researchers to search experiments, download files with MD5 verification, and cross-reference data across 14 databases. It includes 10 commands and 7 agents powered by an MCP server, with no external authentication required.

s1a provides System 1 decision models for Claude Code agents through integration with Jev, Laya, or Cua-S1 Nano models to enable faster and cheaper task execution. It supports browser use, computer use, robotics, and game scenarios with prebuilt and custom agents, delivering 3-6× speedup and 13-25× cost reduction compared to standard chat models.

Vulcan is an agent-first CLI for trading perpetual futures on Phoenix DEX (Solana) that bundles 3 agents and 18 skills for portfolio management, market scanning, and strategy execution like TWAP and grid trading. Paper trading and market data work out-of-the-box; live trading requires opt-in wallet setup with a dangerous-mode flag.

nexus-agents intelligently orchestrates multiple AI coding tools (Claude, Gemini, Codex) by routing tasks to the best model, validating outputs through multi-model consensus voting, and learning from outcomes to improve routing over time. It provides a full development pipeline with 30 MCP tools for agent management, research, memory, codebase intelligence, and quality gates including security scanning.

This Claude Code plugin enables AI-to-AI collaboration by orchestrating multi-provider code reviews and debates across Codex, Grok, Antigravity, Ollama, and Gemini through a unified skill corpus deployed to Claude Code, Cursor Agent, and Pi. It bundles MCP server configurations and provides adapters for host-specific workflows including code pairing, verification, and cross-LLM brainstorming.

This plugin equips Claude Code agents with wallet functionality via the Phantom Connect SDK, enabling token swaps, transaction signing, and address management across Phantom's supported blockchains. It provides 8 skills for app scaffolding, transaction handling, and message signing, plus 2 MCP servers for real-time SDK documentation and wallet operations.

curiosity-stack is a structured research thinking tool that decodes technologies and market signals into actionable business insights by walking users through six layers of systematic questioning — from the initial signal through root causes and industry solutions to named companies and the research landscape. It integrates with enterprise tools and can autonomously track watchlist topics, compare decompositions over time, and find Indian market proxies for global companies.

This plugin automates GitHub workflow and Actions monitoring, managing CI/CD pipelines, pull requests, and repository rulesets directly from Claude Code. It provides skills for watching PR builds, attaching media, reviewing diffs, managing notifications, and building stacked PRs, with agents that configure branch protection and analyze failing logs.

This GitLab plugin provides skills for working with merge requests, monitoring CI/CD pipelines with real-time log streaming, and accessing GitLab's REST and GraphQL APIs, plus hooks that convert GitLab URLs to API calls and catch common GitHub-to-GitLab migration mistakes. It includes a logs agent that extracts relevant error information from failing CI jobs and enforces GitLab-correct syntax patterns.

The lets plugin provides development workflow management with session initialization, code review capabilities, and task tracking through 26 commands organized across 15 agents and 16 skills. It integrates with the lets external tool and executes shell commands while responding to PreCompact and SessionStart hook events.

This plugin provides code review workflows for Claude Code, offering both model-invocable skills to review working diffs and PR comments on GitHub/GitLab, plus background agents that dispatch incoming review requests. It includes follow-up tracking, human review request integration, and multi-angle analysis powered by Sonnet.

Salesforce Claude Code (SCC) is a unified AI development system featuring 17 expert subagents, 57 domain knowledge skills, and 29 automated quality gates for Salesforce development across Apex, LWC, SOQL, Flow, Visualforce, Aura, DevOps, and Agentforce. It integrates with @salesforce/mcp to provide institutional knowledge, code governance, and automated enforcement through hooks that validate quality on every code change.

This plugin detects newly added type ignores and lint suppressions across multiple languages (TypeScript, Python, Go, Rust, Ruby, etc.), then automatically fixes the underlying type errors or replaces unfixable ignores with explanatory TODO comments. It runs automatically via a PostToolUse hook when Claude adds an ignore, and can also be invoked directly with the `/fix` skill for codebase-wide cleanup.

This Claude Code plugin enforces writing style and detects AI-generated language patterns in human-facing prose like PR descriptions, comments, and documentation through hooks that check for vague vocabulary, promotional language, and templated constructions. It provides skills for analyzing writing tropes, rewriting text, scanning for violations, and conducting multi-agent document reviews using configurable wordlists and pattern detection.

This Claude Code plugin reads infrastructure-as-code files (Terraform, CloudFormation, Kubernetes, Docker, and others) to automatically generate architecture and infrastructure diagrams using D2, and keeps them synchronized with code changes via drift detection. The plugin produces multi-level diagrams (detailed and simplified) in light and dark SVG variants, with 950+ cloud and technology icons and animated traffic flow visualization.

Draft maintains persistent shared context across Claude Code, Codex CLI, and Cursor sessions via an append-only log and session hooks, so every team member's AI starts with the same product context, priorities, and recent changes without re-explanation. The plugin's SessionStart hook injects live context snapshots before each session begins, and team members can publish and load shared context via `/publish-team` and `/load-team` commands.

A general-purpose Java coding plugin with 14 skills, 2 agents for architecture guidance, and tools for applying Java 8+ coding standards. It integrates with Maven and uses shell-based analysis to understand Java project structure and enforce best practices.

This Claude Code plugin provides a Java quality toolkit with three integrated agents covering security (OWASP compliance), performance optimization (N+1 queries, memory, threading), and testing frameworks (JUnit 5, Mockito, Testcontainers) for Java 8+ projects. It operates through shell commands and hooks to analyze and improve code quality during development workflows.

A Claude Code plugin that auto-discovers and orchestrates 14 agents and 4 skills at runtime, routing tasks to specialists across MCP servers (context7.com, exa.ai, grep.app) and six hook event types. It integrates upstream open-source agent frameworks (Oh My Claude Code, Everything Claude Code, gstack, superpowers) and tools for token tracking, language server integration, and multi-provider agent routing.

OSS Autopilot is an AI-powered workflow engine that monitors GitHub pull requests, alerts on maintainer feedback, diagnoses CI failures, and surfaces matching issues to streamline open source contributions. It runs as a Claude Code plugin with 9 commands and specialized agents, an MCP server, and a standalone CLI with an interactive Preact dashboard for PR management and contribution tracking.

CodeAlive context engine provides semantic code search and AI-powered codebase Q&A, enabling agents to understand entire codebases beyond open files and trace cross-service dependencies. It includes authentication hooks, a code exploration subagent, and multiple search modes (lexical, semantic, deep cross-cutting), working standalone or alongside the CodeAlive MCP server.

A spec-driven multi-agent orchestration framework for Claude Code that runs entirely on the stock runtime with 13 specialized agents, 38 skills, and 17 guardrail hooks — all defined as pure markdown with no backend required. It provides per-phase model tiers, optional cross-device semantic memory, and opt-in lifecycle hooks for parallel agent coordination and software engineering workflows.

Soleur is a comprehensive AI organization system with 68 specialized agents across engineering, finance, marketing, legal, operations, product, sales, and support that learns from every decision to improve future work. It provides a structured 6-step workflow (brainstorm → plan → work → review → compound → ship) accessible via `/soleur:go` commands, with 102 skills and integration hooks for knowledge accumulation.

A comprehensive Claude Code plugin for Tray e-commerce API integration, providing 36 skills, 11 agents, and documentation for 150+ endpoints including OAuth flows, webhooks, and best practices. It accelerates development for partners and community members building applications on the Tray platform.

wiki-wonka maintains a persistent, LLM-curated knowledge base by ingesting sources into immutable raw files, generating cross-referenced Markdown pages in a wiki directory, and performing consistency checks via linting operations. The agent handles all summarization, synthesis, and bookkeeping while enforcing a schema-driven structure and language configuration across ingest, query, and lint workflows.

This AWS development toolkit plugin provides 35 skills, 11 sub-agents, and 3 MCP servers for designing, building, migrating, and reviewing AWS architectures against Well-Architected best practices. It covers AWS services across compute, storage, networking, databases, and observability, with specialized agents for migration, cost optimization, Bedrock, and AgentCore development.

CodeSensei is a free, open-source Claude Code plugin that teaches coding concepts in context by watching local file and command changes, offering explanations, quizzes, and a martial arts belt progression system based on XP and concept mastery. It stores all learning progress locally with no external uploads, supporting adaptive explanations that adjust to your belt level and professional background.

This Claude Code plugin orchestrates an issue-to-PR workflow that fetches tickets from Jira, Linear, GitHub Issues, or Azure DevOps, optionally pulls linked Figma designs, implements the solution with mandatory plan approval, enforces >95% test coverage and security review, generates e2e tests, opens a PR, and moves the ticket to review. It is stack-agnostic and detects project conventions from CLAUDE.md and .claude/ configuration files rather than imposing frameworks or test setup.

Magician is a full-stack SDLC plugin that automatically inspects projects, detects technology stacks, and orchestrates parallel agents through a complete workflow from design to merged PR with self-learning capabilities. It enforces TDD discipline, manages git isolation, performs multi-agent code review, and accumulates intelligence across sessions by learning patterns from previous work.

MAMA (Memory-Augmented MCP Assistant) lets you save development decisions and checkpoints in a local SQLite database, then retrieves them automatically across Claude Code sessions using hooks and MCP. The plugin tracks decisions with reasoning, provides search capabilities, and injects relevant context when reading files or compacting conversations.

Nano Banana 2 generates and edits images directly in Claude Code using Google Gemini 3.1, supporting text-to-image, inpainting, style transfer, 4K output, search grounding, and multi-image composition through a single /genimage command. The plugin automatically selects between Gemini 3.1 Flash for standard work and Gemini 3 Pro for high-resolution output, requiring only a free Google Gemini API key.

Ploop is an autonomous loop plugin that enables long-running, multi-day work with an independent advisor certifying mission completion while ensuring the anchor survives agent compaction. It manages subscription-safe agents through 2 agents, 6 skills, and lifecycle hooks that coordinate work across sessions and subagent stops.

Refine is a heavyweight multi-agent workflow plugin that cross-examines repository issues across multiple perspectives to reach consensus, then applies only the highest-ROI fixes to code and documentation. It uses a PreToolUse hook to intercept and guide tool execution, with shell capabilities for executing fixes directly.

total-recall provides persistent, cross-tool memory for AI coding assistants with semantic search, multi-tiered storage (Hot/Warm/Cold), and token budgeting across sessions and devices. It integrates with Claude Code, Copilot CLI, Cursor, Cline, OpenCode, and Hermes, offering a local web UI for memory management without external API dependencies.

tx is a Git transaction workflow plugin that opens a branch as an integrity boundary, drives changes through OpenSpec-backed planning and verification stages, and squash-merges only when everything is clean. It uses guard hooks to keep protected branches and sync integrity intact across transactions that may span multiple Claude Code sessions.

Career Navigator is an AI-powered job search companion that combines recruiter, career coach, reverse recruiter, and market analyst functions to manage applications, tailor resumes for ATS systems, and track outcomes in a feedback loop. It integrates with Gmail, Google Calendar, and Microsoft 365 to monitor communications and schedule while learning from your application results over time.

agy-plugin-cc delegates code review and investigation tasks to Gemini CLI or Antigravity CLI (agy) as a cross-model engine, exposing Claude Code-native commands for pragmatic review, adversarial challenge, and background job handling. The plugin spawns the engine binary you install locally and operates no intermediary service—data flows directly from your machine to Google's servers via your chosen CLI.

Vault PKM integrates Claude Code with Obsidian, providing 20 MCP tools for structured knowledge management including semantic search, graph traversal, and enforced metadata templates. It enables bidirectional knowledge flow across conversations and projects through a unified vault with activity logging, link suggestions, and specialized agents for knowledge capture.

The ar plugin provides autonomous execution, file policies, and safety guards for Claude Code and other AI coding assistants through task-lifecycle checks and command safety validation. It integrates natively across multiple harnesses (Claude Code, Codex, Qwen Code, OpenCode, Pi, and others) with hook-based event handling and shared command grammars.

Autonomous experiment loop that continuously optimizes any measurable target (test speed, bundle size, LLM training loss, etc.) by editing code, benchmarking, and keeping only improvements. Includes domain-agnostic optimization engine and specialized LLM training templates for NVIDIA GPUs, with state persistence in git and JSONL for context-resilient resumability.

claudelint is a comprehensive linter for Claude Code projects that validates CLAUDE.md files, skills, settings, hooks, MCP servers, and plugins through both CLI and interactive plugin skills. It checks schema compliance, file structure, circular references, and security issues, with support for auto-fixing and strict validation modes.

claude-watchdog automatically runs a critical post-mortem analysis at the end of each Claude Code session, comparing what was requested against what actually changed in the repository using git diff and delivering a structured review of goals, efficiency, quality, compliance, and recommendations. All analysis happens in-session using existing Claude Code credentials with no external API calls or additional keys required.

story-flow is an agentic development workflow plugin that coordinates planning, analysis, implementation, and QA automation through 5 agents and 5 skills to manage software development tasks end-to-end. It uses 4 MCP servers and npm tooling to orchestrate the development lifecycle without requiring external API keys.

Bullpen is a Claude Code plugin that creates a team of 64 named AI specialists, each with distinct expertise (UI design, backend development, security, database architecture, etc.) and opinionated defaults that you invoke via commands or natural language. Each specialist maintains per-project memory in a local JSON file that learns from your actual development patterns and syncs across clones of your repository.

Delegates self-contained coding and research tasks to the Cursor CLI (cursor-agent) from Claude Code, routing them through Cursor's subscription quota instead of Claude's, with support for single tasks or parallel fleets managed by Claude. Long-running tasks execute in ~4-minute resumable legs to survive network interruptions, and includes a Persian web copywriting pipeline with dependency-free linting to enforce ZWNJ, punctuation, and readability standards.

This plugin connects Claude Code to Fullstory's MCP server to query behavioral analytics, session replays, and customer experience insights directly from AI workflows. It enables programmatic access to session data, user behavior analysis, funnel metrics, and digital experience data for Fullstory beta program participants.

wmux-orchestrator decomposes complex development tasks into parallel Claude Code agents coordinated through dependency-aware execution waves, with optional visual terminal panes via wmux or fallback to native subagents. Each agent operates independently while an orchestrator monitors progress, enforces task dependencies, and triggers automated review once all work completes.

Endor Labs workflow agents and setup for Claude Code that provides 11 agents and 1 skill for scanning and remediating code dependencies across multiple IDE and CLI platforms. The plugin runs shell commands and hooks into Claude Code's tool use workflow to enable automated security and configuration workflows.

A multi-agent development workflow skill that orchestrates Claude Code Agent Teams through five modes (plan, dev, full, auto, bugfix) with collaborative roles like Architect, Developer, Code-Tester, QA-Tester, and Reviewer working through quality gates and approval workflows. Teammates debate directly within teams, execute wave-based task dependencies, track session state across branches, and enrich pull requests with agent notes.

CI-optimized code review plugin that runs 11 specialized review agents in parallel with confidence scoring and posts atomic GitHub PR reviews via the gh API. Supports multiple review profiles (single, lean, full, agent) with configurable severity filtering and focus areas.

A standalone Agent Skill that orchestrates multiple AI consultants (Gemini 3.8 Flash, Codex, GLM-5.3, Kimi K3) and Claude subagents for consensus-driven code reviews, plan validation, and architectural decisions with weighted synthesis and false positive filtering. Invoked via `/council` commands with specialized review modes (security, architecture, bugs, quality, adversarial, etc.) and includes a secret scanning gate using gitleaks before contacting external consultants.

This Control Plane plugin provides 30 skills and 2 agents for managing hybrid multi-cloud deployments across AWS, GCP, Azure, and private clouds, including workload deployment, secret access configuration, networking, and Kubernetes migration tasks. It connects to the Control Plane platform via MCP and executes operations through bash commands integrated with Claude's interface.

F-MCP Bridge connects Figma designs directly to Claude and other AI assistants through 26 skills and 8 commands, enabling bidirectional design workflows like extracting design tokens, generating React code, and performing accessibility checks—all without sending design data to the internet. Runs locally on Claude Code, Claude Desktop, or Cursor with optional Figma API token support for advanced features like version history and comments.

Wizard is a meta-framework that turns repeatable tasks into reusable AI workflows called "spells," with 25+ bundled spells for research, writing, development, and everyday work. It runs as a plugin across Claude Code, Cursor, Codex, Gemini, OpenCode, and Copilot CLI, letting you build and deploy the same skill format in any AI coding tool.

Wizard is a meta-framework that converts repeatable tasks into reusable AI workflows called "spells," with 25+ pre-built spells for research, writing, development, and daily work. It runs across Claude Code, Cursor, Codex, Gemini, OpenCode, and Copilot CLI with no external API keys or paid services required.

This plugin integrates Apollo.io directly into Claude Code with three pre-built skills that automate sales workflows: enrich contacts from partial data, prospect by ICP description, and load leads into sequences with automatic deduplication. All functionality chains Apollo APIs together without tab-switching or manual steps.

CCF is a Claude Code plugin that enforces a context-first, spec-driven development workflow by keeping CLAUDE.md/.claude specifications continuously synchronized with code and grounding design decisions in best practices from Context7 and Microsoft Learn. It provides five slash commands, four analysis/research subagents, shell-based hooks for workflow enforcement, and integration with external knowledge bases—all operating within a single main session to avoid spawning costly separate contexts.

cc-memory is a Claude Code plugin that maintains persistent project memories across compactions and sessions by automatically saving decisions, results, and plans to a local SQLite database with LLM-judged semantic deduplication and reconciliation-on-write. It forces the next session to read a handoff document before responding, enforces a user-intent ledger via a live PLAN.md anchor, and provides FTS5 search and MCP tools for memory access.

Access real-time cryptocurrency market data for 12,000+ cryptocurrencies and 350+ exchanges via 31 MCP tools, including prices, OHLCV candles, and contract lookups. Includes a market-analysis agent and coin-discovery skill with free tier offering 20,000 calls/month without an API key.

Access real-time and historical DeFi data across 36 blockchains via DexPaprika's MCP server, including DEX liquidity pools, token prices, OHLCV candles, and transaction history. The plugin provides an agent for DeFi security analysis (honeypot and scam detection) plus four skills for token security assessment, technical analysis, batch price lookups, and trending pool discovery.

masterplan orchestrates multi-hour engineering work through a durable brainstorm → plan → execute → finish lifecycle, storing all state on disk in run bundles to survive session crashes and compaction. It delegates work to short-lived subagents that return structured digests, keeping the chat session context lightweight while maintaining full resumability.

oddyssey is a CLI toolbox that integrates with OpenTelemetry and Grafana backends to enable Observability-Driven Development, allowing coding agents to observe local and remote application runs and feed insights into spec-driven improvement loops. The plugin provides 4 agents, 9 skills, 7 commands, and 4 hooks to coordinate observability data collection and analysis within the development workflow.

pstack is a workflow orchestration plugin that provides 17 rigorous agents and 61 composable skills to help you write higher-quality code with less manual effort. It enables parallelizable agent workflows designed for speed and code quality, with a SessionStart hook that initializes your development environment.

SAP Superpowers is a Claude Code plugin that transforms Claude into a senior SAP consultant with 61 skills, 25 agents, and 8 slash commands covering the entire SAP lifecycle—from consulting and development to delivery and hypercare. It provides industry-aware and country-localized guidance with zero telemetry, zero API keys, and enterprise-grade data protection through markdown-based hooks.

This plugin connects Claude to WhatsApp through an MCP bridge, enabling message search, reading conversations, sending texts and media, and managing business outreach in any language. It includes a persistent conversation memory system that learns from every interaction, storing contact preferences and communication patterns in a private Notion database to improve engagement over time.

Wicked Garden is an AI-Native SDLC plugin that orchestrates end-to-end feature development through 81 specialist agents, enforced workflow phases, and quality gates that prevent incomplete work. It maintains cross-session memory with 3-tier persistence, enriches every prompt with project context via code search and structural intelligence, and runs entirely offline with local SQLite storage—no external API dependencies.

Cadence is a plan/execute/verify loop for Claude Code that uses adversarial review (Claude subagents or external models like OpenAI, Gemini, DeepSeek) at every gate to validate plans and diffs before code is written. State lives in `.planning/` files on disk rather than in conversation, enabling aggressive context clearing and lean token usage across sessions.

dotforge enforces declarative runtime policies on Claude Code tool calls—like "search before writing" or "no destructive git"—by compiling YAML behavior definitions into PreToolUse hooks that persist session-scoped state and escalate policy violations. It provides 7 agents and 20 skills for bootstrapping, auditing, syncing, and capturing behaviors across multiple Claude Code projects, with hooks operating at PreToolUse, PostToolUse, and Stop events.

linear-prism analyzes Linear issues and requirement documents alongside repository evidence to intelligently decompose them into minimal, independently verifiable implementation tasks with clear blocking dependencies. It then registers the approved task breakdown in Linear as a hierarchy of sub-issues, eliminating speculative prerequisites and layer-by-layer task fragmentation.

The Overloop CLI plugin enables Claude Code to automate sales workflows by managing prospects, campaigns, enrollments, and sourcings through the Overloop API v2 directly from code. It provides full command-line interface integration with features for building and running outbound sequences, managing prospect lists, and automating sales outreach.

A domain-agnostic Claude Code plugin with 54 PM skills, 5 agents, and 6 workflows that guide product teams through discovery, strategy, execution, and communication with enforced problem clarity and leading/lagging metrics. Customizable via domain-context.md for company-specific personas, compliance, and competitive context.

This Claude Code plugin equips Claude with deep BIM expertise and 25 specialized skills to generate ready-to-run Dynamo Python scripts, audit Revit models, detect clashes, manage parameters, create schedules, and automate full construction workflows from plain language. It includes 3 specialized agents (BIM, ACC, and Project Setup) and optional integration with live Revit via external MCP servers like revit-mcp or NonicaTab AI Connector.

This Claude Code plugin provides comprehensive tooling for managing SPECLAN projects, helping developers organize, link, and maintain project specifications as structured markdown files. It includes 13 commands, 7 agents, and 10 skills to streamline specification authoring and navigation workflows.

A starter kit providing code review and teaching agents alongside project setup, testing, and explanation commands, plus a file-formatting hook for Claude edits. It includes three executable commands, two agents, a skill template, and a PostToolUse hook that formats files after Claude modifies them.

Viber is a Claude Code plugin that orchestrates multi-stage software development workflows from requirements gathering through code review and deployment, combining 24 agents and 22 skills to interview stakeholders, plan tasks, build incrementally, and maintain project memory. It integrates with GitHub for issues and pull requests, runs shell commands via Bash, and provides hooks at key decision points to guide developers through structured conversations, prototyping, testing, and continuous improvement cycles.

zd-core is a foundational security and workflow plugin that runs Node-based guardrails (pre/post-tool hooks) to block dangerous operations like recursive deletes and credential exposure, while providing stack detection and developer handoff documentation. It includes skills for architecture analysis, secrets auditing, onboarding setup, and a terse output style, with all scripts platform-agnostic and testable as CI gates.

A Claude Code plugin that automates the full development cycle from spec through plan, implement, review, and clean phases using markdown commands and bash hooks. It provides 12 agents, 31 skills, and 14 hooks to manage task decomposition, CI gates, code review with multiple perspectives, and artifact cleanup with zero external runtime dependencies.

Agent Skills is a collection of 21 production-grade engineering workflows and quality gates that guide AI coding agents through the full software development lifecycle—from spec definition through deployment. The plugin activates relevant skills automatically based on context or through seven slash commands (/spec, /plan, /build, /test, /review, /code-simplify, /ship), encoding senior engineering practices into consistent, repeatable processes.

cli-dispatch is a multi-backend delegation hub that routes tasks to worker CLI backends including DeepSeek-powered Claude Code, Antigravity, OpenAI Codex, OpenCode, and GitHub Copilot. It provides deterministic execution with session tracking, read-only mode sandboxing, MCP isolation, and optional auto-install of missing workers.

Claude of Alexandria is a biblical study and exegetical analysis plugin that retrieves linguistic data (morphology, discourse features, vocabulary, textual variants) via an MCP server and applies rigorous analytical skills using TDD methodology to prevent interpretive errors. It offers context-aware skills, a deep-study workflow with structured stages, and optional team-based discussion, with built-in guardrails to ensure Sonnet or Opus execution and prevent Haiku usage.

This Claude Code plugin implements a persistent-memory and runtime-discipline layer that remembers corrections, grounds edits in verified facts, and transforms fixes into reusable instincts through the Mulahazah engine, built on 7 Laws of AI Agent Discipline. It ships with 28 bundled skills, 14 hooks, 4 agents (code-reviewer, security-auditor, test-engineer), 29 commands, and a GitHub Action transcript linter that feeds real work history back into sharper instincts.

The core plugin provides a vendor-neutral foundation for multi-agent orchestration with 13 specialized agents, 37 skills, 16 lifecycle hooks, and a project-aware CLI for coordinated agent work. It enforces architectural integrity through pre/post-tool gates that protect sensitive files, validate code shapes, track sessions, and manage model switches.

Dossier is an evidence-first project documentation system that produces an audit-ready 23-file package with every material claim traced to a source and verification state, enforced through three independent verification passes and a binary release gate. It ships a post-merge GitHub Actions job that keeps documentation current by opening automated documentation PRs, with built-in security isolation between privileged and unprivileged operations.

An AI-native E2E browser test runner that lets you write tests in plain JSON without code, powered by 17 MCP tools, 3 agents, and 4 slash commands. It supports parallel execution across multiple Chrome drivers (browserless, CDP, Lightpanda, Obscura, Steel), 28+ built-in actions, visual verification, network debugging, and a real-time dashboard.

Flow is a skill-driven GitHub workflow automation plugin for Claude Code that encodes team knowledge as composable skills and enforces quality through strict TDD, acceptance-criteria-based verification, and durable goal tracking via a runtime layer at .flow/. It includes 33 skills, 23 commands, 10 agents, and 12 hooks that work with bash, git, gh, jq, and python3 to block unsafe operations, compound learning across sessions, and provide evidence-based verification with a trust ledger for goal execution.

Guild turns a single coding session into a self-evolving team of 15 specialist agents organized across engineering, content, and commercial domains, coordinated through a v2 lifecycle (init·ideate·plan·build·qa·ops) with structured decision capture and shadow-mode gating. The plugin provides 110 skills, 3 machinery agents, 22 commands, and 21 hooks to manage brainstorming, team composition, specialist planning, context assembly, dispatch, review, and continuous self-improvement within your project.

imperium-brain is a comprehensive startup operations plugin with 18 skills spanning competitive research, content creation, and business advisory across CEO, product, marketing, sales, finance, and engineering domains. It intelligently routes requests across 8 sub-agents and 20 slash commands, automatically detecting implicit dependencies (e.g., running research before creating data-driven LinkedIn posts) and chains execution order when needed.

This Claude Code plugin integrates Ix Memory to turn Claude into a graph-reasoning engineering agent with cognitive skills for understanding, investigation, impact analysis, planning, debugging, architecture auditing, and documentation synthesis. It hooks into Claude's tool use and file editing to maintain a persistent code knowledge graph and minimize token usage through structured memory queries.

jig is a Claude Code workflow layer that enforces spec-driven development with built-in review gates, memory continuity, and deterministic hooks to prevent common AI-assisted coding pitfalls. It scaffolds a structured workflow from idea through implementation and independent review, bundling 20 skills and 19 hook-based guardrails to keep projects lean and reviewable across sessions.

A 12-phase autonomous workflow orchestrator that takes tasks from discovery to production, with user approval at task selection and plan stages, then runs implementation, multi-agent review, and shipping autonomously. Supports parallel isolated workflows via git worktrees and integrates with GitHub Issues, GitHub Projects, GitLab, and local task files.

This unified code review plugin for jj repositories uses a two-phase pipeline with generalist-first reviewers that scale to change size, plus emergent specialist agents triggered by repeated review patterns. It provides structured findings via shell commands with options for progress tracking, GitHub PR posting, and JSON output.

This plugin enables Claude Code to interact with the Solana blockchain by querying accounts, analyzing transactions, and executing operations through two automatically-triggered agents and built-in safety safeguards. It includes network switching, keypair management, and mainnet access controls that require explicit risk acceptance before any real-value operations.

SweetClaude is a full lifecycle software development partner for Claude Code that manages project structure, testing, design, and deployment through 122 skills and 11 agents coordinated via conversational commands. It teaches itself about your project preferences and applies structured workflows to handle planning, implementation validation, and quality gates without requiring manual skill invocation.

Taskplane coordinates multi-stage software delivery by connecting design, planning, implementation, and verification through agents and skills that can run independently or in sequence. It keeps requirements, dependencies, and review findings linked throughout the task lifecycle, with dashboard visibility and optional autonomous execution within user-defined boundaries.

A Claude Code plugin that enables agent coordination through shared blackboard, decision tracking, and context assembly across multiple agents and tools. It provides 9 skills, 2 agents, and 2 commands with hooks into the agent lifecycle to coordinate tool use and session management.

A design audit plugin that scores projects across 12 dimensions—color, typography, accessibility, layout, and more—using WCAG and APCA standards, reporting exact file locations, measured values, and specific fixes for each issue. It works as a Claude Code plugin, Agent Skills, or standalone CLI tool with zero runtime dependencies and no external keys required.

A Claude Code plugin that enforces epistemically rigorous reasoning through 97 sourced patterns from historical figures, routed automatically to 15 problem-shaped skills with commit-time enforcement gates. The system prevents unsourced claims, magic numbers, and untraceable decisions by blocking commits until cited evidence or measurements are provided, making uncertainty and provenance explicit across the agent reasoning lifecycle.

This plugin provides 400+ tools for creating, analyzing, and optimizing campaigns across Google Ads, Meta Ads, LinkedIn Ads, TikTok Ads, Amazon Ads, and ChatGPT Ads via natural language, including keyword research with live CPC data, creative fatigue detection, and budget optimization. It connects to Adspirer's MCP server with free-account OAuth sign-in, ships 5 slash commands and 1 performance-marketing agent, and ensures all new campaigns are created paused for human review.

This Claude Code plugin spawns and manages autonomous background agents that work in isolated git worktrees with persistent state, automatically tracking completion via hooks and supporting resume/merge workflows. Agents follow a structured 5-phase process (analyze, plan, implement, verify, commit) and accumulate project knowledge across sessions to incrementally tackle complex tasks.

The atk plugin provides 16 skills, 1 agent, and 25 commands for AI/LLM development patterns including RAG, embeddings, LangGraph, prompt engineering, and multi-agent orchestration. It offers AI-native development utilities with no external API dependencies, running entirely through local shell execution.

Claude WP Builder automates the conversion of demo HTML mockups into production WordPress themes with ACF/SCF fields, bilingual support, and SEO — processing section-by-section or entire sites in one pass via command-line workflows. It transcribes client-approved static designs into fully functional themes, never inventing design and always starting from an approved demo.

CC Commander is a guided AI PM plugin that orchestrates development workflows from planning to shipping, featuring 22 specialist sub-agents, 84 click-first /ccc-* skills, 30 lifecycle hooks with 51 handlers, and 2 bundled MCP servers (context7 and sequential-thinking) plus 16 opt-in via /ccc-connect. It runs natively in Claude Code Desktop, CLI, Cursor, Windsurf, Cline, and Codex with no signup, no API keys required, and MIT licensing.

A comprehensive Convex plugin for Claude Code that bundles backend design skills, a live-scaffolding quickstart tool, code-writing and code-review subagents, and an MCP server for deployment introspection. It steers Claude toward Convex idioms and primitives for building reactive, type-safe backends with schema, real-time updates, authentication, file storage, and scheduled jobs.

ctk is a Claude Code plugin that maintains session continuity through persistent ledger tracking, automatic dirty state warnings, and tiered context window monitoring across project sessions. It stores session state locally in `.claude/continuity/` and provides commands to save progress, create handoff snapshots, and resume work without re-explaining context to Claude.

dtk is a DevOps toolkit plugin with 15 specialized skills, 2 agents, and 12 commands for infrastructure and backend development on AWS, Terraform, Kubernetes, and serverless platforms. It includes pre-commit hook setup, observability, cost optimization, and code review capabilities for Python Lambda, PostgreSQL, and REST APIs.

dx-aem provides AEM-specific agents and skills for component verification, dialog inspection, screenshot capture, and QA automation across Adobe Experience Manager projects. It bundles AEM MCP and Playwright MCP servers to enable JCR content queries, component dialogs, page management, and browser automation—all integrated into the dx-core development workflow plugin.

Eklavya turns agent generation time into adaptive learning by asking Socratic questions grounded in the code Claude Code just wrote, with mastery tracked in a local knowledge graph. Questions are progressive (Tier 1 through 5), never repeated, and can optionally gate commits until comprehension is demonstrated.

A comprehensive engineering toolkit for Claude Code with 27 skills, 5 agents, and 21 commands covering quality gates, architecture decisions, testing strategies, automated research, and workflow orchestration. It supports autonomous code review, Sentry investigation, codebase analysis, and experimentation loops with shell command execution capabilities.

ftk is a frontend development toolkit providing 18 skills and 4 agents for UI/UX design, shadcn/ui components, browser automation, JSON rendering, and Remotion explainer videos. It includes 11 commands for design workflows, prototyping, and integration with Google Stitch AI for AI-powered UI generation.

This Claude Code plugin integrates Google's Gemini CLI to perform code reviews, whole-codebase analysis, and task delegation with Gemini's 1M token context window. It provides commands like /gemini:review, /gemini:analyze, and /gemini:consult, backed by a Node.js companion that manages background jobs and integrates with Claude Code's session lifecycle.

marc is a Claude Code plugin that organizes a seven-agent team (tech lead, engineer, SRE, design, security, review, and research specialists) to collaborate on code reviews and development tasks through an IRC-styled interface. The team coordinates through the tech lead agent and uses 3 skills and 7 hooks to manage workflow across multiple repositories.

This is a comprehensive knowledge base and agent skill for understanding, building, and auditing Claude Code mods—TypeScript add-ons that extend the Claude Code editor with panels, commands, hooks, and safety guards. It provides 100+ linked notes, a scanner for static mod analysis, step-by-step recipes, a graded catalog of 40+ mods, and the mods-secretary agent for Claude Code integration.

nxtg-forge is a governance-native AI development platform providing 33 agents, 24 commands, and 27 skills with comprehensive security controls including 4 blocking guards, Semgrep scanning, and drift detection. The plugin uses hook events for pre/post tool execution and command stop gates to enforce compliance and prevent unintended behavior during agent execution.

This plugin teaches coding assistants to build Pixeltable applications with multimodal databases, computed columns, vector search, RAG, and tool-calling agents across 25+ AI providers. It provides a contract for declaring table schemas as TableModel classes, creating tables with pxt CLI commands, and serving HTTP routes with Pixeltable's orchestration platform.

sonmat is a Claude Code verification plugin that injects structured doubt and reasoning checks (guard/inspect/witness/punch/devil/scribe) into agent workflows and subagents. It uses markdown discipline blocks, automated hooks at session start, and persistence layers to surface verification reasoning and prevent silent failures.

trailhead turns GitHub Issues into a structured project map with 22 commands and 8 agents that guide teams through a discuss→plan→execute→verify workflow, using atomic commits and cohesion-clustered skills to resolve issues systematically. It requires only an authenticated gh CLI and Node.js, shipping as a dispatcher that hooks into PreToolUse, PostToolUse, and SessionStart events to orchestrate project execution.

This Claude Code plugin delegates coding tasks to Google's Antigravity (agy) CLI, enabling full rescue, resume, background execution, review, and status tracking directly from the Claude Code environment. It provides 12 commands, 1 agent, and 3 skills with session lifecycle hooks (SessionStart, SessionEnd, Stop) and shell execution capabilities.

An executable six-stage AI-native software development lifecycle plugin for Claude Code that gates each stage—Plan, Design, Build, Test, Deploy, Maintain—at human checkpoints, producing version-controlled Markdown artifacts (intent.md, spec.md, plan.md, etc.) and enforcing sensitive-path protection via hooks. The plugin ships two reviewer subagents, four control hooks (artifact-gate, prod-guard, session-context, prompt-nudge), and templates for project governance via REVIEW.md and bands.yaml control bands.

ArcKit is an Enterprise Architecture Governance Harness providing 76 slash commands across strategy, architecture, delivery, and assurance within Claude Code, leveraging 31 agents and 6 MCP servers for autonomous research and compliance enforcement. The plugin integrates with AWS, Azure, GCP, and government data sources to guide architecture decisions and maintain organizational standards through automated hooks and interactive guidance.

Persistent, cross-session task management for Claude Code where tasks survive between sessions so work started by one agent can be picked up by another. Built on AgentDB with typed schemas, auto-increment IDs, and virtual filters, providing 20+ MCP tools for full task lifecycle management including planning, specs, implementation, and handoff.

This plugin provides 17 editing skills for the BashCut video editor, covering workflow planning, footage surveying, rough cuts, beat-based editing, audio mixing, captions, color grading, effects, and visual planning. It integrates with BashCut's MCP server and includes specialized agents for surveying and reviewing that run on cheaper models.

brand-forge generates on-brand logos, social templates, and marketing graphics as scalable SVG assets with zero required keys or accounts; AI imagery via Gemini or OpenAI is opt-in and off by default. It stores a versioned visual brand profile and enforces accessibility checks (contrast, clear-space, palette) on all generated assets before output.

This Claude Code plugin creates LinkedIn content and career strategy by combining two AI-powered skills: one drafts posts in storyteller voice with monthly content calendars, and the other provides career coaching for job search, networking, and interview prep. Both skills share context through memory files and can dispatch a career-advisor subagent for strategic decision-making.

chamnan is a context index that preserves repository architecture, decisions, work state, and reusable engineering context (MAP.md, STATE.md, sessions/, memory/, skills/, tools/, milestones.md) across Claude Code sessions, replacing expensive file scanning with a compact markdown index. It runs entirely on your machine with no network calls, no database, and no embedding model, and writes for two dozen other agents including Cursor, Windsurf, Copilot, Zed, Aider, and Gemini CLI.

compounded turns Claude into a learnable agent that captures corrections and converts them into verified rules that improve with demonstrated reliability across sessions. Rules progress from proposed to autonomous tiers based on successful usage, all stored locally without cloud or daemon.

Content Multiplier expands one piece of source content into a week of on-brand posts across multiple channels and languages, enforcing brand voice and compliance throughout. It works entirely within Claude Code using slash commands and includes subagents that strategize angles, draft channel-specific formats, and review output for brand consistency.

A PM-native Claude Code plugin that enforces structured software delivery through session lifecycle management, named code reviewers, and 41+ workflow skills that route work from product intent through scoped plans to ship decisions. It treats Claude as an engineering manager handling implementation while the PM retains authority over scope, tradeoffs, and ship/no-ship calls via a decision architecture backed by Python-enforced doctrine and 87 hook scripts across nine lifecycle events.

Coordinator is a core orchestration plugin that addresses six failure modes in AI-assisted development through session lifecycle management, named code reviewers, research pipelines, and 26 workflow skills spanning planning, review, synthesis, and architecture auditing. It enforces quality gates from specification through execution via structured agent routing, write-ahead status protocols, and persistent decision capture.

A Claude Code plugin that implements a wiki-grounded verification loop (TDD/PDCA/Reflexion) for driving development tasks to completion, with every design decision routed through a bundled semantic-layer knowledge base before code is written. It supports both single-task implementation and multi-session orchestration with parallel workers, automatic knowledge capture, and wiki PR generation for continuous methodology improvement.

docpin grounds Claude in version-matched documentation by detecting installed library versions from your project's lockfiles and fetching docs pinned to those exact versions across npm, PyPI, crates.io, and Go. It automatically triggers before Claude writes code importing third-party libraries and provides explicit commands to pull docs for specific libraries or topics.

DotnetPilot is a Claude Code plugin that provides 29 commands, 14 specialized agents, and Roslyn-powered semantic analysis to catch common .NET mistakes like missing DI registrations, unsafe EF Core migrations, and architecture violations in real time. It includes convention-aware scaffolders, clean-architecture enforcement, DI verification, and project lifecycle management with 16 skill packs backed by an MCP server.

Green Keeper automatically fixes failing tests and type errors with minimal changes while enforcing a "no fake-green" rule that prevents weakening tests, silencing errors, or cheating with type-widening. It provides `/green` and `/cover` commands plus a Stop hook that blocks you from leaving red that your turn introduced, running entirely locally with zero external dependencies.

Hafıza adds persistent LLM-wiki memory to Claude Code, ingesting raw sources into interlinked markdown pages indexed for efficient querying without re-scanning. It includes an archiver agent for page synthesis, a lint agent for consistency checking, and a hook that protects raw sources from accidental modification.

This Claude Code plugin captures vocabulary you naturally use in coding sessions and transforms it into personalized flashcards with FSRS scheduling, all processed locally without external APIs or accounts. The trainer offers six screens for spaced-repetition study including practice drills, analytics, and support for 35 languages across multiple scripts, with no data leaving your machine.

A markdown-only collection of 16 agent skills for Claude Code, Codex, Gemini CLI, and other coding CLIs — covering architecture (vertical-slice, C4 models), code quality (low-complexity, testing strategy), review workflows (dual code/Codex debate, PR explanations, comprehension quizzes), and specialized guidance (STE simplified English, Argentine ELI5 explanations, agent context auditing). No runtime dependencies or build steps.

Objection enforces a mandatory adversarial review process for pull requests, where an accuser model identifies issues in the diff, a defender refutes with specific file:line evidence, and your session judges the verdict before a local hook and CI gate allow PR creation. It integrates with Claude Code, Cursor, GitHub Copilot, and other AI agents without requiring hosted services or bot accounts.

OPM is a Claude Code plugin that enforces a test-first, spec-driven engineering workflow by splitting work across fresh-context subagents, holding quality gates with mandatory code review, and capturing decisions to a persistent ledger that survives session resets. It includes skills for design brainstorming, architecture planning, test-driven execution, verification, and turning specs into narrated explainer videos.

pptx-craft provides 7 agent skills and a CLI to build native, layered, animated PowerPoint decks with staged quality gates that block progress until content and design pass checks. The plugin generates editable `.pptx` files with real text boxes, separate image layers, and native PowerPoint motion graphics, plus optional MP4 video export with frame-accuracy verification.

Pre-submission compliance auditor that scans iOS and Android app projects against Apple's Review Guidelines and Google Play Developer Policy, flagging rejection risks with exact file references and auto-fixing safe violations. Spawns five parallel subagents to audit privacy, IAP, permissions, metadata, and crash risks, outputting a terminal report plus an interactive HTML dashboard.

Styx is an MCP-native AI API gateway plugin that routes, manages, and observes LLM traffic across multiple providers with built-in MCP server support. It includes commands for setup and status monitoring, an ops agent for diagnostics and cost optimization, and MCP tools for provider management, usage tracking, caching, and request routing.

Superfast is an enterprise-grade Claude Code plugin that combines test-driven development, debugging, and collaboration patterns with a FastMemory engine for handling massive codebases beyond native context windows. It automatically maps repositories into a deterministic cognitive graph, guides systematic design through Socratic brainstorming, and orchestrates autonomous subagent-driven development with iterative code review and planning.

Transmute Framework is a Claude Code plugin that autonomously transforms a business plan into a fully deployed product through a 25-stage pipeline called Plan Casting, where AI agent teams handle everything from tech stack selection to feature implementation, security auditing, and production deployment. The framework executes 23 automated stages plus 2 manual decision points, generating specifications, scaffolding projects, implementing features in priority order, and producing deployment-ready code and documentation.

Vibe Dev is a harness-first plugin for Claude Code that enforces discipline through 24 agents and 29 skills operating across six hook events, using three models (Fable 5.1 for architecture, Opus 5 for coding, Sonnet 5 for assembly) with 87 tracked enforcement mechanisms to turn business ideas into shipped products with verified evidence rather than claimed completion. Every principle is backed by real gates that block invalid transitions, require proof of execution (exit codes and output fingerprints), and physically deny agents the ability to bypass verification — ensuring "done" means actually done, not compiled.

This plugin provides natural language server operations for Ubuntu VPS, enabling Nginx log analysis, PM2 service monitoring, backup verification, and health checks without SSH terminal access. It includes four commands and a weekly digest agent that consolidates infrastructure checks into an actionable report, with optional integration to Notion for logging.

apple-hig ships a complete on-disk reference of Apple's Human Interface Guidelines (iOS, iPadOS, macOS, watchOS, tvOS, visionOS) and automatically designs and reviews UIs to match them, with a router skill that loads only the files relevant to the current task. It includes verified design tokens, typography, color palettes, layout rules, and accessibility minimums from the current Liquid Glass/Golden Gate generation, all without fetching Apple at runtime.

This standalone Agent Skill wraps xcodebuild and swift CLI tools to automate building, testing, and archiving Swift packages and Xcode projects for Apple platforms (iOS, macOS, tvOS, watchOS, visionOS). It discovers available schemes and targets, manages simulator destinations, and integrates with Xcode workflows without requiring external API keys or services.

The claude-code-kit plugin orchestrates 33 specialized agents and 16 skills to automate the full development lifecycle—from task planning and implementation through code review, security scanning, and testing. It includes built-in hooks for secret protection and code formatting, and integrates with external tools like ruff and MCP servers for research and API development.

CLI Subagents lets you spawn and manage background agents across multiple Claude Code, Codex, or Antigravity instances, each on different accounts with shared MCP servers and configuration. Subagents communicate bidirectionally, handle quota spillover automatically, and run with safety constraints (read-only or sandboxed review modes) all controlled through a single setup.

The Doom Design System plugin equips AI agents with comprehensive knowledge of a neubrutalist React component library, including component APIs, design tokens, theming, and coding standards. It includes 4 agents, 3 commands, 1 skill, and 1 hook that intercept pre-tool-use events to guide component selection and implementation.

This Claude Code plugin maintains a persistent private project context that can be shared across multiple coding agents and worktrees, allowing coordinated development across different environments. It hooks into SessionStart to initialize and propagate project context automatically.

fakoli-state is a local-first, SQLite-backed project-state layer that turns PRDs into reviewed, lockable work packets for humans and AI agents to coordinate against without conflicts. It exposes 23 CLI commands, 22 MCP tools, and 6 specialized agents (tier-mapped to Opus/Sonnet/Haiku) to manage requirements, task claims with enforced leases, and evidence-backed state across parallel work.

The gws plugin exposes 100 skills across all Google Workspace services (Gmail, Calendar, Drive, Docs, Sheets, Slides, Chat, Meet, Forms, Classroom, Tasks, Keep, People, Events, Admin Reports, and Apps Script) via the open-source gws CLI, along with 11 role-based agents, 15 slash commands, and 44 automation recipes. It requires the gws CLI to be pre-installed and authenticated, and provides helpers for common workflows like email triage, meeting prep, file organization, and safety features via Model Armor integration.

This HubSpot sales plugin provides workflow automation for sales teams, including contact import, call preparation, daily briefs, follow-up drafting, call logging, contact lookup, and pipeline overview features. It connects to HubSpot via an MCP server to streamline common sales operations.

This Claude Code plugin saves structured session memories to `.memory/` folders, letting Claude resume projects with full context on startup rather than forgetting previous work. It includes an optional blog generation pipeline that transforms session logs into polished posts via GitHub Actions and the Anthropic API.

This Claude Code plugin provides structured templates, validation scripts, and best-practice guidance for creating and publishing agent skills and Claude Code plugins that conform to Anthropic's platform standards. It includes a shell-based audit tool (skill-md-audit.sh) and covers the full workflow from creation through marketplace distribution and CI/CD integration.

This plugin implements the witness team's practices as a service and skills suite, tracking threads by team and seat with editors, inventory keepers, and hooks that capture session meaning without exposing raw transcripts. It includes skills for first impressions on peer sessions, podcast dialogue generation, prompt pre-editing, and team-fit analysis, all coordinated through a local API and tmux session management.

Mia is a voice-driven development companion that listens for voice takes recorded on an iPhone and delivers drafted, edited, and revised answers within a Claude Code session tied to an episode. The plugin integrates a background listener, a developmental-editor agent, and a phone-capture service to create a cross-device workflow where voice input from the user's phone automatically triggers Mia's response cycle.

neo-research turns any topic into structured agent expertise by building a question tree, discovering sources, fetching content to a knowledge store, and distilling targeted excerpts into compact mental models—without bloating context windows. It includes sandboxed Python execution in Docker containers for code analysis, DSPy sub-agents, and REPL-based knowledge distillation.

This plugin connects Claude Code to the Releases.sh changelog registry, enabling search and tracking of software releases across organizations and products through an MCP server and command interface. It includes skills for discovering changelog sources, managing ingestion, parsing release notes, and analyzing cross-company release trends.

Fetches and sanitizes public web pages and search results with network policy enforcement, URL validation, and content cleanup to reduce attack vectors. Provides MCP tools for fetch, search (via Brave API), and URL checking with configurable rate limits and domain policies.

Spec First guides developers through a three-step workflow: define requirements in an approved spec file, implement code from that spec by copying patterns from the repo, and generate documentation—all from the terminal. The plugin enforces spec-first discipline by requiring approval of requirements before implementation begins, with validation checks that gate each phase.

Showtime is a local video production studio that generates motion graphics, voiceovers, music, sound design, captions, and platform-ready video exports entirely on your machine from natural language descriptions. It integrates with Claude Code and other coding agents through Agent Skills, requiring only Node.js and uv, with no cloud services or API keys needed.

This plugin automates multilingual social media content creation and scheduling for LinkedIn and X, generating posts in English, Portuguese, and Spanish from a Google Sheets CMS with optional infographic prompts. It includes an autonomous weekly batch agent that fills calendar gaps, and a performance review command to analyze post engagement patterns.

This plugin automates the analytical core of strategy consulting—from problem definition through independent research, validation, synthesis, and executive-grade deliverables—while leaving high-value judgment and client relationships to the consultant. It orchestrates a multi-agent workflow that deploys parallel researchers, pressure-tests findings, and produces a cliché-free Word report backed by sourced claims.

Superpipelines enables design and execution of multi-agent AI coding loops with enforced write/review isolation, crash-resumable state management, and cross-platform compatibility across Claude Code, OpenCode, Codex, Cursor, Windsurf, and Cline. It structures autonomous AI agent workflows into disciplined engineering loops with verifier constraints, step-level control, and integrated audit trails.

Supervisor is a 27-agent quality-control layer for Claude Code that researches externally verifiable claims, delegates work to specialized experts, runs tests, and enforces a final release gate before delivery. It includes independent reviewers, anti-hallucination verification, adversarial red-teaming, and coding/frontend specialists to catch outdated docs, fabricated APIs, broken code, and unsupported claims before they reach users.

This Claude Code plugin applies systems thinking methodology to infrastructure and architecture decisions, using extraction and synthesis agents to surface hidden costs, vendor assumptions, scaling risks, and dependencies before they become production problems. It produces structured artifacts like Complexity Heat Maps, Decision Briefs, and Risk Summaries grounded in source evidence from vendor documentation and design materials.

V-Bounce is an AI-native SDLC orchestrator that coordinates 12 specialized agents through a unified software development lifecycle including requirements analysis, design, unified TDD implementation, code review, and deployment with per-phase quality gates and state management. The agent-first architecture uses explicit input/output contracts, tech-aware context injection, and multi-layer quality assurance across feature, bugfix, hotfix, and change request workflows.

version-sentinel hard-blocks dependency additions and updates until the agent records a fresh, source-cited version check against package registries (npm, PyPI, Cargo, NuGet), preventing hallucinated or stale versions from entering the codebase. It enforces this constraint via PreToolUse hooks that intercept Edit, Write, and install commands before they land, rejecting changes with exit code 2 if no recent registry lookup is cited.

workkit is a Claude Code plugin that transforms GitHub Issues into an automated SDLC pipeline, with an agent crew that specs, builds, reviews, and tests each issue from inbox to shipment. The system uses GitHub labels for workflow states, 5 delegated agents, 9 skills, and 28 hooks to enforce quality gates at each stage without manual intervention.

This plugin enforces a 7-step workflow discipline for AI-assisted development through 24 skills grounded in Covey's 8 Habits, from requirements gathering through monitoring, and includes cross-verification checklists to prevent common shipping mistakes. It runs as a thin harness with on-demand markdown skills that guide spec-first development across any AI coding tool (Claude Code, Cursor, Codex, Windsurf, Aider).

This Claude Code plugin provides a verification gate for AI-generated work by anchoring goals into versioned run files and spawning independent validators to prove correctness before allowing closure. It operates via slash commands (`/a:run` and `/a:setup`) with a bundled CLI tool that runs over Bash, requiring no external APIs or MCP servers.