Browse plugins

Superpowers is a complete software development methodology library of 15 composable skills that guides coding agents through structured workflows: requirements gathering, design review, TDD-driven implementation planning, and subagent-driven autonomous task execution with continuous inspection and review. It activates automatically on session start across multiple coding agent harnesses (Claude Code, Cursor, Devin, Gemini CLI, GitHub Copilot CLI, Grok Build CLI, and others) without requiring explicit invocation or API keys.

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.

This plugin restores the deprecated Explanatory output style by injecting a SessionStart hook that instructs Claude to provide educational insights about implementation choices and codebase patterns throughout each session. It formats these insights in a consistent "Insight" block before and after code generation to explain design decisions and conventions.

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.

This plugin activates an interactive learning mode via SessionStart hook that prompts Claude to request meaningful code contributions at decision points while also providing educational insights about implementation choices. It combines the unshipped Learning output style with explanatory functionality to transform passive observation into hands-on learning experiences.

Ralph Wiggum implements continuous self-referential AI loops that repeat the same prompt through a Stop hook until task completion, allowing iterative refinement within a single Claude Code session. The technique runs Claude in a while-true pattern with persistent file state, letting the model read its own past work and fix failures autonomously.

Three-layer security review for Claude-generated code: pattern-based warnings on edits, LLM-powered diff review on Stop, and an agentic commit reviewer that traces data flow across files to catch injection, XSS, SSRF, hardcoded secrets, and 25+ vulnerability classes. Uses Anthropic's Claude models (Opus 4.7 by default) to review diffs and trace security issues before code is committed.

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.

Claude-mem is a memory compression system for Claude Code that persists context across sessions through automated archival and retrieval of conversation state. It integrates via lifecycle hooks and shell commands to maintain searchable memory without external API dependencies.

Claude-Mem for Cowork captures tool use via hooks and streams fragments to cmem.ai, where a Pro server runs the observer and compiles observations that are injected back into new sessions and spawned agents. Retrieval works via the existing MCP memory_search endpoint; capture is inert until cmem.ai's ingest/context endpoints ship.

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.

This plugin provides lightweight startup hooks that initialize and manage Headroom deployments during Claude Code and GitHub Copilot CLI sessions. It runs shell commands at session start and before tool use to ensure a Headroom environment is ready, with flexible discovery of the Headroom binary across multiple installation locations.

This plugin restructures Claude's code output to be ADHD-friendly by leading with actionable steps, numbering tasks, suppressing tangential information, and making progress visible. It applies 10 formatting rules via a skill hook that runs at session start to transform verbose explanations into concise, action-oriented guidance.

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.

This Claude Code plugin guides legacy codebase modernization through interactive steps that extract business rules, build interactive dependency maps, create approval-required upgrade plans, and then verify that modernized code behaves identically to the original using independent proof mechanisms. It supports any language and any modernization path (version upgrade, language rewrite, or architecture rebuild), includes security hardening, and generates one-page HTML reports tracking progress across assessment, mapping, rules extraction, planning, building, and verification phases.

This plugin recreates the deprecated Explanatory output style by injecting a SessionStart hook that instructs Claude to provide educational insights about implementation choices and codebase patterns throughout each session. The insights are formatted as highlighted blocks explaining specific decisions, conventions, and trade-offs in the code.

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.

This plugin activates a SessionStart hook that injects instructions into every coding session, encouraging Claude to request meaningful 5-10 line code contributions at decision points rather than implementing everything automatically. It combines interactive learning with explanatory insights about implementation trade-offs, design patterns, and codebase-specific decisions.

Ralph Loop implements self-referential AI iteration loops in Claude Code, using a Stop hook to repeatedly feed the same prompt back until a completion signal is detected. This enables autonomous iterative development where Claude can build, test, debug, and refine work across multiple passes within a single session.

This Claude Code plugin performs three-layer security review of code edits: pattern-based regex warnings on edits, LLM-powered diff review when Claude finishes a response, and agentic commit review that traces data flow to catch multi-file vulnerabilities like injection, XSS, SSRF, and hardcoded secrets. It integrates via hooks into the Claude Code editing workflow and supports customizable org-specific policies through markdown configuration files.

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.

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.

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 hooks into PreToolUse events to detect and warn about 12 common security anti-patterns (command injection, XSS, SQL injection, unsafe deserialization, code injection, and GitHub Actions workflow injection) before code execution happens. It caches session state and auto-cleans stale files after 30 days, and can be disabled per-session via environment variable.

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.

This plugin runs an offline self-improvement cycle at session end, harvesting past Claude Code interactions to identify recurring tasks and replay them locally to refine the agent's consolidated CLAUDE.md memory and SKILL.md skill definitions behind a held-out validation gate. Changes are staged for human review and only go live when explicitly adopted via `/skillopt-sleep adopt`, with a mock backend enabled by default to avoid API costs.

A Claude Code plugin that maintains persistent project planning files (task_plan.md, findings.md, progress.md) on disk and injects them via lifecycle hooks to preserve planning context across context-window resets, crashes, and /clear commands. It includes 13 commands and 6 skills with automatic recovery from project files and optional catchup modes for aggregate session counts.

Context Mode is an MCP server that reduces context consumption by 98% through sandboxed code execution across 11 languages and maintains session continuity using FTS5-indexed SQLite tracking with automatic BM25 ranking on compaction. It enables agents to analyze data by writing scripts rather than reading raw files into context, and preserves task state and decisions across conversation resets without dumping data back into the window.

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.

Watch converts video files or URLs into timestamped frames and transcripts for AI agents, extracting native captions when available and optionally using local WhisperX or Groq/OpenAI transcription. It runs as a Claude Code plugin or standalone Agent Skill across multiple platforms including Claude Desktop, VS Code, terminals, and compatible agent frameworks.

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.

Worktrunk is a Claude Code plugin that integrates Git worktree management with activity tracking, showing which branches have active Claude sessions via 🤖/💬 indicators in `wt list` output. It provides configuration guidance for LLM commit messages, project hooks, and worktree paths, plus a `/wt-switch-create` command to spawn isolated branches for parallel AI workflows.

This Claude Code plugin equips AI agents with 12 skills, a fal MCP server, and a CLI to reverse-engineer, modify, and test mods for almost any PC game—generating art, 3D models, and audio with fal, then documenting the process in a shared knowledge base. The agent automates the full modding loop: engine reconnaissance, code analysis, mod building, asset generation, in-game testing, video capture, and knowledge sharing.

Expert Claude Code skills that teach AI how to build production-ready n8n workflows using the n8n-mcp MCP server, covering expression syntax, node configuration, validation, and deployment patterns. The plugin enforces correctness through a hooks layer and includes 14 complementary skills plus a router and validation enforcement.

Ouroboros sits in front of Claude Code as a plugin that clarifies vague coding requests through an interview before generating specifications, blocking spec generation until ambiguity scores pass a threshold. It redacts verification commands and expected-output assertions from the contract given to the worker, asking instead for the outcome to enable self-improving, replayable AI coding workflows.

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.

Official Expo plugin providing 24 AI agent skills for building, deploying, upgrading, and debugging Expo apps across React Native, iOS, and Android, with clear separation between open-source framework skills and paid Expo Application Services (EAS). Connects to mcp.expo.dev and includes navigation, animations, design systems, data fetching, native modules, App Store submissions, EAS Build/Update/Observe, and remote simulator capabilities.

a2a-client is an MCP server that provides security-hardened access to Agent2Agent (A2A) agents through the official SDK, exposing tools for discovering agent cards, sending/streaming messages, and managing tasks with operator confirmation gates. Every remote agent card is treated as untrusted input with strict validation, SSRF protection, credential isolation, and confirmation-gated task cancellation.

This plugin adds transparent cloud storage operations to Claude Code by integrating Box CLI, automatically syncing file changes to Box via hooks while providing a skill that teaches agents safe, guardrail-aware Box operations like versioning, conflict detection, and narrow-default sharing. It works with any Box account (personal, business, or enterprise) and includes explicit operation modes for searching, downloading, uploading, and sharing files while preventing unsafe patterns like duplicate creation and public-by-default sharing.

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.

Claudebase backs up and restores your entire Claude Code environment—including agents, skills, hooks, rules, and memory—to a private GitHub repository with multi-machine conflict detection and timestamped backups. It supports switching between named profiles (work, personal, team), secret scanning to block API keys and tokens, and dry-run previews before syncing configuration changes.

Claude Never Forgets maintains persistent memory across sessions by automatically saving user messages, responses, and corrections to a local project memory file, then reloading them at session start to preserve context, preferences, and decisions. The plugin consolidates memories when they exceed a threshold to keep only important information while removing noise.

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.

Five live-detection skills for Databricks workspace diagnostics—cost-leak-hunter, cluster-forensics, uc-migration-pilot, streaming-guardian, and bundle-medic—that run real queries and API calls against your workspace via the databricks-workspace-mcp server. Each skill audits specific Databricks components (billing, cluster events, Unity Catalog readiness, streaming health, and asset bundles) and degrades to advisory mode when the MCP is unavailable.

A Claude Code plugin that automatically formats code using Prettier with support for JavaScript, TypeScript, JSON, CSS, Markdown, and other file types through hooks and manual commands. It provides automatic formatting on file edits, validation commands, configurable rules, and Agent Skills activated by keywords like "format my code" and "fix formatting".

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.

j-rig is a Claude Code plugin that implements an eval-guided improvement loop for SKILL.md files using a thin wrapper over the @intentsolutions/refiner CLI package. It provides a 3-layer cost-tiered hook architecture (sinker/line/hook) that validates skill edits, captures rollouts, and gates commits with agentic checks to ensure only improvements with no regressions are applied.

PM AI Partner provides 12 specialized agent skills covering modes like Thought Partner and Technical Analyst, along with 6 workflow commands for planning, brief-writing, meeting prep, and competitive analysis. Three automation hooks integrate quality gates, draft tracking, and commit reminders into the PM's development workflow.

This Claude Code plugin automatically formats markdown files in your workspace using prettier whenever Claude stops responding, triggered by a Stop hook with configurable organization and path exclusions. It runs asynchronously in the background with zero configuration required, supporting custom exclusions, optional AI-generated commit messages, and comprehensive logging.

ServiceGraph is a metrics-enriched business dataset API that ships 18 agent skills to search and filter agencies, directories, newsletters, and product-launch platforms with a unified DSL and credit-based access model. The plugin includes a branded entry point that works against any dataset plus 14 specialized skills for US professional services (law, marketing, design, consulting, accounting, IT, engineering, HR, PR, cybersecurity, and more) and 3 product-directory skills for software launches and backlink opportunities.

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.

This travel-assistant plugin coordinates real-time weather forecasts, live currency conversion, timezone management, and AI-generated itineraries to provide complete trip planning in minutes. It combines 4 AI agents (travel planner, weather analyst, local expert, budget calculator) with 6 commands to handle destination research, packing lists, and multi-city route optimization.

Vibe Guide transforms Claude Code work into non-technical plain-language progress summaries, hiding diffs and logs so non-developers can pair program with AI. It uses stepwise execution with friendly updates, error checklists, and optional learning micro-explanations, tracking progress in a `.vibe/` folder.

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.

memsearch is a Claude Code plugin that automatically captures and indexes session summaries across conversations, enabling Claude to retrieve relevant past work when starting new sessions. It uses local ONNX embeddings (no API key required) and integrates with Claude Code's hooks and skills system to maintain a searchable semantic memory of your project history.

TDD Guard enforces Test-Driven Development principles by intercepting file edits and writes in Claude Code to block operations that skip tests or over-implement. It auto-detects your test framework and validates changes against TDD rules using hooks that run on tool use, session start, and user input.

Shunt redirects large file reads and code generation to AiKA delegation modes through the Portal CLI, saving 82-94% of tokens by blocking I/O-heavy operations before they enter Claude's context. It uses hooks to intercept file reads over 350 lines and delegates to preconfigured bulk-reader and code-writer modes that handle the work autonomously.

This plugin acts as a security reminder hook that warns developers about potential security vulnerabilities—including command injection, XSS, and unsafe code patterns—when they edit files. It uses a Python-based analysis triggered by PreToolUse events to flag risky code patterns before they're executed.

The prompt-improver plugin evaluates user prompts at submission and tool-use time, asking clarifying questions for vague requests and routing complex tasks through targeted nudges like plan-mode assessment, workflow guidance, and subagent orchestration. It uses a skill-based architecture with hook-level evaluation to improve Claude's first output and reduce correction round-trips.

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.

claude-reflect is a self-learning system for Claude Code that automatically captures corrections and workflow patterns, storing them in CLAUDE.md for permanent memory across sessions. It offers two modes: a Python plugin using hooks to queue learnings, and a mod that surfaces rules in real-time with one-click saving.

Hivemind provides cloud-backed persistent memory using Deeplake, allowing you to read, write, and share memory across multiple Claude Code sessions and agents without losing context between interactions. The plugin uses hooks to automatically capture session events and tool usage, enabling seamless memory persistence throughout your workflow.

A PreToolUse hook that intercepts and blocks destructive git and filesystem commands (like `rm -rf`, `git reset --hard`, `git push --force`) before execution by parsing command semantics rather than simple patterns, so flag reordering and shell wrappers cannot bypass it. It runs on Windows, macOS, and Linux across seven coding agent CLIs including Claude Code, Codex, Gemini CLI, GitHub Copilot CLI, Kimi Code, OpenCode, and Pi.

This plugin integrates the Azure MCP Server and 38 curated Azure skills to enable Claude Code agents to manage Azure infrastructure, deploy resources, and troubleshoot cloud services with structured decision-making and guardrails. It provides 200+ tools across 40+ Azure services including deployment workflows, diagnostics, cost optimization, AI/ML, identity management, and Foundry integration.

CC Safety Net intercepts and analyzes shell commands before execution, blocking destructive operations (like `git reset --hard`) and secret file access (SSH keys, `.env` files) by parsing command intent rather than string matching. It runs as a PreToolUse hook on node and works across multiple coding agent CLIs including Claude Code, Cursor, and GitHub Copilot CLI.

brooks-lint performs AI code reviews against six decay-risk dimensions synthesized from twelve classic engineering books, annotating findings with citations, severity levels, and remedies. It offers six analysis modes (PR review, architecture audit, tech debt assessment, test quality, health dashboard, auto-fix) grounded in proven software engineering principles.

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 hooks into Claude Code's session start and user prompt submission events to capture usage metrics, rejections, and session statistics. It collects telemetry data and displays it in a unified dashboard for monitoring plugin performance and user behavior patterns.

This Claude Code plugin synchronizes CLAUDE.md documentation and a permissions allowlist with an external Python script, then refreshes context on demand via a PostToolUse hook. It provides four commands to manage plugin metadata and permissions without requiring external API keys.

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.

This plugin intercepts write operations and blocks a predefined list of AI buzzwords before they're used, helping developers maintain more authentic language in their code and documentation. It leverages Python-based hooks to filter and flag overused terminology in real time.

This plugin hooks into the PreCompact event to automatically summarize file paths, root causes, and open questions, keeping context intact during code compaction. It relies on an external shell script (precompact_priorities.sh) to process and organize information before compaction occurs.

This plugin reviews changed code for redundancy, reuse opportunities, and over-engineering, then applies simplification fixes automatically. It runs as a pre-tool-use hook and uses Python to analyze and refactor code.

Tavily web search and content extraction MCP that provides intelligent web search capabilities and content extraction through model context protocol integration. Includes smart tool selection hooks to automatically route web-related tasks to the appropriate Tavily methods based on context.

This plugin provides Ultralytics Platform API integration and YOLO26 training skills for Claude Code, with pre/post-tool-use hooks and a push guard that blocks force pushes via Python. It enables direct interaction with Ultralytics services and model training workflows while enforcing safe git practices.

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 Claude Code plugin provides end-to-end build, test, deploy, and inventory workflows for Power Apps component framework (PCF) code components targeting model-driven apps, Power Pages, and canvas apps, with guided setup and Microsoft-maintained templates. It requires Node.js 20+, PAC CLI, .NET SDK, and Azure CLI to run local scaffolding, deployment, and verification tasks.

deja-vu indexes past coding sessions across 34 supported agents (Claude Code, Cursor, Qwen, OpenClaw, Copilot) and surfaces relevant context automatically using local BM25 search before you ask, with credentials redacted at index time. The plugin integrates via 5 hooks (SessionStart, PreToolUse, PostToolUse, PreCompact, UserPromptSubmit), an MCP server, and a /deja command to query your session history without external APIs or embedding services.

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.

Build, edit, run, and debug Power Automate cloud flows directly from Claude Code using the FlowAgent MCP server, with support for surgical edits, environment copying, run management, and expression validation. The plugin runs offline with a self-contained MCP engine and uses local Azure CLI authentication, requiring only Node.js 18+.

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.

FDEOps is a Claude Code plugin that maintains a persistent engagement memory (the "fieldbook") for Forward Deployed Engineers, consultants, and agency developers, organizing client work across phases (land, discover, plan, build, ship, close) and automatically loading context from prior sessions. The @fde skill routes work through the methodology while capturing decisions, debriefs, and stakeholder updates in a local .fde/ directory that persists across coding agents.

This plugin tints a Terminal.app window with project-specific colors during Claude Code sessions and brightens the window when a response arrives while unfocused. It uses hooks to intercept commands like `,api` to tag sessions and track their state without invoking the model.

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.

Hyperflow is a multi-agent orchestration plugin that chains eight slash commands—spec, scope, dispatch, audit, deploy, trace, scaffold, and cache—into a structured engineering pipeline with cross-session memory and adaptive flow profiles. Every step assigns persona-stitched workers with multi-level thinking-model review, parallel task execution, and automatic triage to match task complexity to cost-effective model allocation.

screenshot-janitor automatically detects screenshots created during each Claude Code session and prompts you at the end to move them safely to the Trash rather than cluttering your Desktop. Files are moved (never permanently deleted) using system Trash with zero external dependencies, supporting both macOS and Linux.

This plugin adds a security reminder hook that triggers before code edits to warn about potential security vulnerabilities like command injection, XSS, and unsafe code patterns. It uses python3 to analyze code and flag risky practices in real time.

This plugin provides 7 skills for designing, building, deploying, testing, and debugging AWS Serverless applications using SAM and related tools. It includes an MCP server and shell integration for hands-on serverless development workflows.

This plugin provides expert guidance on the AWS database portfolio, helping developers design schemas, execute queries, and choose the right database for their workload. It leverages MCP servers and AWS knowledge integration to assist with database design and migrations.

This Claude Code plugin analyzes codebases and generates AWS infrastructure deployments with cost estimates, CDK/CloudFormation IaC, and draw.io architecture diagrams using official AWS4 icons. It connects to three AWS MCP servers for real-time pricing data, IaC best practices, and architecture guidance.

Open Steps provides plain-language session reports, operator instructions, and decision framing to make AI-driven development transparent to non-technical builders who run the agent but don't read code. It transforms technical jargon and commit details into clear verdicts on whether work is done, what's needed next, and what new technical debt was created.

VibeWise is a Claude Code plugin that guides you through software design decisions before implementing code, asking you to articulate your approach and tradeoffs at each step. Claude writes the code based on your confirmed design and explains the changes, helping you learn architecture and planning while maintaining control over decisions.

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.

Unbrowse replaces WebFetch, WebSearch, and browser MCPs with a hosted cloud browser MCP that supports scraping, discovery, and saved logins via hooks that intercept tool use and session start. The plugin requires authentication via OAuth or API key and redirects browser operations to Unbrowse's cloud endpoints instead of local tools.

Hippo Memory is a biologically-inspired memory system for Claude Code that learns from errors and past sessions, using decay, retrieval strengthening, and sleep consolidation to maintain relevant context. It automatically injects session-start context, pins key rules on every prompt, captures and prioritizes failures with 2x decay, and compacts transcripts while preserving working state—all locally without external API calls.

Recall maintains fully-local session memory for Claude Code by logging activity to `.recall/history.md` and auto-summarizing it with a local TF-IDF + TextRank algorithm into `.recall/context.md`—no external APIs, no model calls, no data leaves your machine. Each new session can resume from the saved context, eliminating the need to re-explain the project and stretching your subscription's token budget.

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.

capcut-cli allows Claude Code to create and edit CapCut and JianYing projects directly from the command line, supporting subtitles, SRT/ASS import, timing, speed, volume, keyframes, masks, filters, effects, templates, linting, preview rendering, and conversion of long-form content to shorts. The tool works on local draft files with no external APIs or servers required, and outputs fully editable projects that can be opened and further refined in CapCut or JianYing.

The Shopify AI Toolkit plugin gives Claude Code agents access to Shopify documentation, GraphQL/Liquid/UI extension code generation and validation, and store management capabilities through the Shopify CLI. Skill scripts send usage telemetry to shopify.dev by default, which can be disabled via environment variable or opt-out file.

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.

This Claude Code plugin exposes hundreds of Unreal Editor tools via MCP, including actors, blueprints, materials, Niagara, Control Rigs, Sequencer, State Trees, Gameplay Ability System, and automation testing. It requires Unreal Editor with ModelContextProtocol and AllToolsets plugins enabled, and runs a SessionStart hook to inject project context into Claude's understanding of UE conventions.

The dxos plugin integrates DXOS Composer as an MCP server for Claude Code, enabling durable project and task tracking via `/dxos:project` command and QA test execution via `/dxos:qa`. It maintains a committed registry of work-streams and per-project TASKS.md ledgers, with optional cloud backend support through a Composer account with passkey authentication.

Auto-stage hooks into Claude Code's Edit|Write operations to automatically run `git add` on every modified file, keeping git status synchronized with Claude's changes. The hook respects .gitignore, runs shell-free to prevent command injection, and logs all staging outcomes without requiring manual intervention.

This Claude Code plugin installs a PreToolUse hook that blocks dangerous Bash commands (rm targeting home/root directories, fork bombs, curl|sh, force pushes, git reset --hard, chmod 777, docker volume rm, etc.) before they execute. Three configurable safety levels (critical/high/strict) control what gets blocked, with per-level ask mode allowing you to approve or reject matches instead of hard-denying them.

bounty-board scans your repository for TODO/FIXME/HACK comments and skipped tests, pricing each as an aging bounty whose XP grows with git-blame age, then injects the top 3 as side quests and verifies payouts when markers disappear. It integrates via SessionStart, PostToolUse, and SessionEnd hooks to track your tech debt as a gamified burn-down economy.

cache-tax warns developers before their next message triggers a costly prompt cache rewrite after the 1-hour cache window expires, showing the dollar cost upfront via a UserPromptSubmit guard and SessionStart hook. It also renders a status-line segment displaying cache countdown, rewrite costs, and session statistics without requiring a separate plugin installation.

This PreToolUse hook intercepts destructive Bash commands (rm, rmdir, mv, mkdir, touch, find) and blocks or prompts when the target path differs only in case from what exists on case-insensitive filesystems like APFS and NTFS. It properly resolves command context through cd chains, subshells, quotes, and shell connectors without making probe filesystem calls.

A PreToolUse hook that prevents agents from modifying guardrail configuration files (settings.json, hooks.json, .mcp.json, plugin manifests, and optionally instruction files) across Bash, Edit, MultiEdit, and Write operations by deny-by-default filtering. The hook logs all decisions locally and supports three safety levels (critical, high, strict) with optional prompt-instead-of-deny modes.

This Claude Code plugin tracks per-file context costs by hooking into tool results and attributing tokens to the files they loaded, then renders a leaderboard of your repo's most expensive files at session end or on demand. It uses local byte-to-token estimates (~4 bytes/token) and configurable pricing to help developers identify which files consume the most context.

The plugin mines Claude Code session transcripts via hooks on stop/compact events to extract and record approaches that were tried then reverted, storing reason and token cost in a per-repo registry. It then injects "already tried" warnings on matching prompts and asks for confirmation before edits reintroduce previously-reverted code hunks.

dead-rules-audit passively audits compliance with CLAUDE.md rules by hooking into Claude Code's edit events (SessionStart, PostToolUse, SessionEnd) and tracks violations with deterministic keyword matching, then renders a worst-first scorecard highlighting chronically-ignored rules. All analysis happens locally with zero network calls or external dependencies beyond Node.js.

This PostToolUse hook automatically formats Python files with ruff and JavaScript/TypeScript/JSON/Markdown/YAML/HTML files with prettier immediately after Claude writes or edits them. File paths are passed safely via argv to prevent shell injection, unsupported files are skipped silently, and all outcomes are logged to ~/.claude/hooks-logs/.

git-safety is a PreToolUse hook that prevents destructive git and GitHub CLI operations in Claude Code by denying branch-unsafe commands (commits/pushes/merges on main/master) and risky gh operations before they execute. It runs synchronously at configurable safety levels (critical/high/strict) and logs every blocked command locally without network calls.

guard-pack bundles seven security and safety hooks (spawn limits, config protection, dangerous command blocking, secret protection, test isolation, git safety, case sensitivity) into a single Node process that runs on tool calls. It evaluates guards in a fixed order with the first blocking verdict winning, and includes detailed logging to ~/.claude/hooks-logs/ while making no network calls.

Audits CLAUDE.md and .claude/rules/*.md files for hidden or hostile directives (invisible Unicode, bidi overrides, command injection, secret exfiltration) and locks the session if violations are found. Enforcement spans three hooks: InstructionsLoaded detects, while UserPromptSubmit and PreToolUse prevent any execution until a human fixes or clears the poisoned file.

nerf-receipts is a local telemetry plugin for Claude Code that passively records per-session signals (tool-failure rate, edit churn, turn counts, tokens-per-task) keyed by model version, then renders trend cards with sparklines to detect statistically meaningful shifts when a model changes. All data stays on your machine—it records only counts and file paths, never tool inputs, commands, or transcript text.

This Claude Code plugin fires on permission prompts, idle waits, and elicitation dialogs, classifying each notification and posting a Slack Block Kit card with the tool permission request, project name, session ID, truncated message, working directory, and timestamp. It requires only a Slack webhook URL via CCH_SLA_WEBHOOK environment variable and never blocks your session, even if the webhook is unreachable.

A PreToolUse hook that screens every Read, Edit, Write, and Bash call against tiered patterns to block or prompt on attempts to access or exfiltrate sensitive files (.env, SSH keys, cloud credentials, keystores) and dangerous shell commands. Matches are denied or converted to a prompt with the exact pattern id and reason, with tunable safety levels (critical/high/strict) via the HOOK_SAFETY_LEVEL environment variable.

protect-tests is a PreToolUse hook that prevents agents from making test suites pass by deleting, renaming, or skip-disabling tests instead of fixing code. It detects and blocks removal patterns across pytest, unittest, jest/mocha/vitest, Go, JUnit/TestNG, NUnit/MSTest, RSpec, and Rust, with three configurable safety levels while always allowing new tests and legitimate test edits.

This plugin embeds a reviewer-facing provenance receipt into PR bodies when Claude runs `gh pr create` or `glab mr create`, recording tool calls, agent-authored lines, and test commands with exit codes. A PostToolUse hook maintains a per-session ledger, while a PreToolUse hook rewrites the PR body to include real prompt count, estimated spend, test tally, and agent-vs-human authored-line split.

Logs every Claude Code session as a durable markdown note with timestamps, file edits, and bash commands (secret-redacted), using three lifecycle hooks to seed, append, and finalize the record. Supports cross-device sync by writing to an Obsidian vault or iCloud folder via the CC_SESSION_LOG_DIR environment variable.

Standup-autopilot captures what agents actually accomplished from session transcripts—tasks, test results, branches, and blockers—and rolls them up into a daily standup card without relying on commits or tickets. It snapshots each session's outcome at Stop/SessionEnd events, redacts credentials before storing, and re-injects previous blockers on SessionStart to keep the agent context current.

This PreToolUse hook tracks cumulative subagent spawns across a Claude Code session and prompts for approval at configurable thresholds (default: ask at spawn 20, deny at spawn 60), counting nested spawns from inside subagents toward a shared per-session budget. It restores the spawn-cap guard that Claude Code removed in version 2.1.224, using an append-only ledger to prevent budget-counting race conditions during parallel spawns.

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.

A Claude Code plugin that orchestrates full album production from concept to release, coordinating research, lyrics, Suno music generation prompts, audio mastering, and promo materials through 53 specialized skills and an 80+ tool MCP server. Multi-model coordination routes creative tasks (lyrics, concepts) to Opus, reasoning work to Sonnet, and mechanical operations to Haiku.

nah is a context-aware safety guard for Claude Code that intercepts tool use before execution, classifying actions as safe, ambiguous, or dangerous based on operation type, path context, and command patterns. It protects against risky Bash commands, file access to sensitive locations, suspicious shell patterns, and network code execution through a fast local decision layer.

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.

This Claude Code plugin intercepts user prompts via a UserPromptSubmit hook to enforce skill evaluation before generating any response. It runs shell commands as part of its evaluation flow.

Chisle reduces Claude's output tokens by 44% on coding tasks through zero-fluff prose rules, YAGNI-first code decisions, and aggressive tool-output compression injected per session. It auto-detects 11+ agents (Claude Code, Pi, Cursor, Windsurf, Cline, Kiro, Codex, Gemini, Copilot, OpenCode, Hermes) and rewires each with a single command.

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.

The astronomer-data plugin bundles an Airflow MCP server and 34 specialized skills for data engineering workflows, enabling AI agents to explore data warehouses, author pipelines, manage DAGs, and run SQL-based analysis through a background Jupyter kernel. It integrates with Claude Code, Cursor, and other agentic coding tools, supporting both open-source and Astronomer-hosted Airflow deployments.

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.

ClaudeForge is an automated toolkit for creating, maintaining, and syncing CLAUDE.md files across Claude Code projects with a hard 150-line cap, automatic chaining via sub-files, and embedded Karpathy behavioural guidelines. It provides lifecycle hooks (PostToolUse, Stop), three parallel audit skills for drift detection and dependency scanning, and slash commands for initialization, enhancement, and synchronization.

MemStack provides 130 battle-tested skills for Claude Code spanning deployment, security, databases, git workflows, and more, with skills auto-activating on demand through markdown-based commands and a Python-based MCP skill loader. The plugin includes 86 free skills built-in, with 44 additional Pro-exclusive skills available via license activation.

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.

Reins intercepts tool calls via pre/post hooks to block destructive actions, route high-risk operations to human approval, and maintain an immutable audit trail of all decisions. It protects against vulnerabilities covered in OWASP MCP, ASI, and Agentic Skills Top 10 threat models by analyzing commands before execution and logging outcomes to a local decision log.

This Claude Code plugin automates FedRAMP compliance authorization using Key Security Indicators (KSIs), continuous monitoring, and machine-readable policies synchronized from official FedRAMP documentation. It provides shell-based commands and hooks for compliance notifications to streamline the authorization process.

grc-loop is a Claude Code plugin that implements a Ralph-loop mechanism for iterative GRC workflows, driving `/grc-engineer:*` commands to automate gap remediation burndowns and quarterly evidence collection sweeps. It uses a state file watched by a Stop hook to repeat prompts until a completion criterion is met, stopping short of destructive operations and handling manual-only or uncollectable items gracefully.

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.

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.

Claude STT is a speech-to-text plugin for Claude Code that captures voice input via a hotkey and transcribes it locally using the Moonshine STT model with ~400ms latency. All audio processing happens on-device with no external services called, and the transcribed text is directly inserted into the Claude Code input field.

AI Team OS extends Claude Code with autonomous multi-agent orchestration through 9 lifecycle hooks, enabling a "self-driving AI company" that continues executing work, improving itself, and coordinating across specialized agent teams without constant prompting. The system includes 25 agent templates, 8 meeting structures, 7 workflow pipelines, task prioritization, failure analysis ("Failure Alchemy"), and transparent decision tracking—all managed via Python and FastAPI backend with React frontend.

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.

This plugin provides 31 Databricks skills for the Claude CLI, Apps, Lakebase, Model Serving, Lakeflow Jobs, Spark Declarative Pipelines, and Declarative Automation Bundles (DABs), along with utilities for classic-to-serverless migration. It requires Python and integrates via shell commands and hooks for session lifecycle and tool usage events.

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.

Herald is a standalone notification system for Claude Code plugins that sends alerts via GitHub issue creation and webhooks (Slack, Discord, generic), with SSRF protection and configurable source labels. It registers a Stop-hook judge that decides whether to auto-continue when a turn ends, preventing runaway loops while allowing intentional multi-turn work.

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.

Leyline provides shared infrastructure and pipeline building blocks for Claude Code plugins, including quota management, error handling, authentication patterns, and service registry utilities. It enables cross-plugin communication and system stability through standardized patterns for resource tracking, rate limiting, and crash recovery.

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.

OpenQodex is a Claude Code plugin that runs security and lint scanners (Semgrep, Gitleaks, OSV-Scanner, ShellCheck, Ruff) on your changed code, then spawns a separate Claude reviewer that validates each finding and generates a unified report. It integrates with git pre-push hooks to enforce review policies and runs entirely on your own Claude login with no external API keys required.

Oracle is an ONNX Runtime inference daemon plugin that provides local ML model inference over HTTP with explicit opt-in activation through a dedicated Python 3.11+ virtual environment. The daemon runs isolated from the system Python and manages its own lifecycle via SessionStart and Stop hooks, requiring no external API keys or third-party services.

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.

Pordee is a Claude Code plugin that compresses Thai language responses by removing politeness particles, filler words, and unnecessary grammar while preserving technical accuracy, reducing output tokens by 60–75%. It operates through slash commands (/pordee, /pordee lite, /pordee full) and keyword triggers, offering two compression levels with a session statistics feature.

Finance Guru is a self-hosted family office engine that provides typed Python calculators, a private SQLite ledger, and specialist agents for portfolio research, quantitative analysis, and financial operations—all running inside Claude Code with data that never leaves your machine. It includes 20+ CLIs for risk, momentum, volatility, correlation, optimization, backtesting, and other financial metrics, each validated with Pydantic and backed by a 1,100+ test suite.

This Claude Code plugin provides agent skills and a hosted MCP server for deploying, configuring, monitoring, and troubleshooting applications and infrastructure on Railway, including management of services, environments, deployments, databases, object storage, networking, and observability. It runs a shell-based hook before tool use and connects to the Railway MCP server at mcp.railway.com to enable Railway operations directly from Claude Code.

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.

Sage is a lightweight security layer that intercepts tool calls (shell commands, URL fetches, file writes) and checks them against multiple threat detection layers including URL reputation, local heuristics, prompt injection detection, and supply-chain checks before execution. It integrates with Claude Code and other AI coding assistants via hooks that monitor PreToolUse, PostToolUse, and SessionStart events to prevent dangerous actions.

Lumen is a 100% local semantic code search engine for Claude Code that indexes your codebase using Go AST parsing and embeds code with Ollama or LM Studio, reducing API costs by up to 39% and token usage by up to 66% compared to baseline AI coding workflows. It exposes vector search through an MCP server with no cloud dependency, external API keys, or npm requirements.

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.

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.

Codebase Mapper automatically creates and maintains a current map of your project structure that Claude loads at the start of each session, tracking files, flows, dependencies, and conventions across any stack. It monitors code changes throughout sessions and keeps the map in sync with incremental or full updates as needed, eliminating the need for Claude to rediscover your codebase each time.

Live Rules keeps project instructions in front of Claude Code by storing atomic rules in .claude/live-rules/rules/ and injecting them at SessionStart and when prompts or edits match. Rules are authored in natural language via the add-rule skill and automatically managed as individual Markdown files with a generated manifest for efficient, content-aware delivery.

Model Gateway adds GPT and Grok models to Claude Code's /model picker via a local proxy that routes requests to OpenAI and Grok while keeping Claude models on Anthropic. The plugin requires Node.js and your own ChatGPT/Codex or Grok subscriptions; no API keys are stored in the plugin itself.

This Claude Code plugin provides local, metadata-only telemetry that records session, tool, and subagent lifecycle events into SQLite on your machine, with optional integration to PostHog, Grafana, or generic OTLP endpoints through an OpenTelemetry Collector. All telemetry payloads exclude prompts, responses, code, tool inputs, credentials, and environment values, with every external sink strictly opt-in and configurable through local configuration files.

Quartermaster automates setup, health checks, and capability discovery for Claude Code projects by analyzing bounded session histories and proposing changes one at a time—all installations and edits require explicit approval. It manages Toolshed plugin installations, workspace configuration, and suggests missing skills or improvements based on accumulated work patterns, with local scripts protecting privacy by reducing transcripts to aggregated summaries before they reach the model.

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.

devteam transforms Claude Code into a full engineering organization with 14 specialized subagents (planner, fullstack-engineer, refactor-specialist, migration-engineer, frontend-designer, critic, vuln-verifier, debugger, db-expert, onboarder, tool-expert, web-researcher) and 20 automation hooks enforcing closure discipline, fact-driven reasoning, and exhaustiveness across the P7/P9/P10 methodology. It wires pre-commit secret scanning, MCP health tracking, cost monitoring, test running, and design quality checks to prevent bugs, security issues, and cost overruns before code reaches production.

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 PostToolUse hook reminds developers to update CLAUDE.md documentation files when git status or git log reveals changes that may affect contracts, APIs, or domain structure. It integrates with the project-claude-librarian agent to prompt documentation updates before commits.

This Claude Code plugin uses PreToolUse and PostToolUse hooks to detect and prevent common secrets leakage patterns such as environment variable echoing, secret file reads, tokens in URLs, and missing gitignore/permissions on sensitive files. It helps developers catch security misconfigurations before they happen by monitoring tool usage and enforcing safe patterns.

This experimental UserPromptSubmit hook automatically considers and activates useful skills when processing user prompts. It integrates with Claude Code to enhance skill discovery and application during interactions.

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.

AgenticMail gives each Claude Code agent its own real email address and phone number, with email coordination between agents running as subagents under a shared Anthropic OAuth token. All data stays self-hosted on the user's machine, with agent dispatch triggered by incoming mail over real SMTP/IMAP backed by Stalwart.

skills-for-humanity is a structured toolkit of 200+ invokable reasoning methods organized across 34 domains (logic, ethics, creativity, decision-making, systems thinking, communication, and more), each applying a specific framework to help Claude think more rigorously about problems. The plugin runs these methods as commands prefixed with `/s4h-`, allowing users to apply history's most rigorous thinking procedures repeatably, inspectably, and composably.

deep-project transforms vague, high-level software project requirements into well-scoped planning units through AI-assisted interview and decomposition, producing focused spec files ready for /deep-plan. It orchestrates a workflow of structured Q&A, split analysis, dependency mapping, and spec generation to break large projects into manageable components.

LeanKG is an enterprise-ready code knowledge graph built as a Claude Code plugin that integrates via MCP hooks to provide impact analysis, dependency tracking, code search, and context generation across multi-repo codebases. It reduces token usage by 65% and tool calls by 85% through structured indexing with Postgres/pgvector and exposes 85+ MCP tools for environment governance, incident tracking, and requirements traceability.

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.

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.

DevGlobe shows your coding activity on a live interactive globe while you work with Claude Code. The plugin tracks tool usage and prompt submissions to update your presence on a global map in real-time.

Superpowers Symfony is a skill library with 44 expert skills, 7 specialized agents, and 13 commands providing version-accurate Symfony expertise for coding agents, covering API Platform v4, Doctrine ORM 3, TDD with Pest & PHPUnit, Symfony Messenger, security/voters, and DDD/hexagonal architecture patterns. It integrates with Claude Code, Codex CLI, Grok Build, OpenCode, Cursor, Windsurf, GitHub Copilot, Gemini CLI, and aider through a SessionStart hook that runs runtime detection to adapt guidance to the target Symfony version and environment.

Claude Code plugin that packages 29 agentic skills for Meta Quest and Horizon OS development, powered by the metavr CLI and MCP server for device management, app debugging, performance analysis, and store submission workflows. Skills cover Quest app setup, Unity/WebXR integration, Spatial SDK, Platform SDK, and XR-specific debugging and optimization tasks.

claude-carbon tracks the CO2 emissions of Claude Code sessions with live estimates displayed in the terminal status line and a dedicated desktop app pane showing historical usage patterns. It persists session data locally to a SQLite database, backfills history from existing transcripts, and provides slash commands for carbon reports, PNG cards, and pull request footprint analysis.

Converts human-written SOPs into deterministic agentic workflows with static topology validation, bounded control flow, and typed field ownership contracts. Bundles three methodology skills (`six-rung-ladder`, `agentic-sop`, `agentic-workflow-audit`), a `/sop-flow` orchestration command, project-scoped regression gates via Stop-hook, and a portable `agentic-sop-kit` with built-in verification and cross-domain examples.

alcoa-guard is a deterministic ALCOA+ data-integrity linter that checks Attributable, Contemporaneous, Complete, Accurate, and Consistent properties in code while surfacing human-judgment items (authorization, gap justification) as a checklist for manual review. It runs standalone against CSV/JSON records with a declared contract or integrates with agentic-sop-kit run directories, outputting a DRAFT report that requires human verification.

A linter and scaffolder for Claude Code plugins that validates manifests and plugin structure against a strict grammar, plus generates compliant plugin skeletons. It runs standalone using pure stdlib without external dependencies, checking manifest invariants, hook protocols, and test harness requirements.

Procoder is a Claude Code plugin that equips AI coders with 34 commands spanning nine domains (security, CI/CD, DevOps, GitOps, performance, maintainability, documentation, clean code, and best practices) plus a code index, enforcing quality gates through hooks that the agent cannot bypass. The agent stays in control while the plugin's binary computes findings—formatting violations, secrets, conflicts, lint issues, and test failures—and reports them for the agent to act on, never modifying code directly.

Second Opinion is an independent adversarial honesty reviewer that checks whether claims in a DRAFT output are backed by evidence, catching fabrication, transcription errors, invented IDs, and unsupported conclusions via deterministic code checks plus a capped advisory LLM pass. The plugin runs in FULL mode against agentic-sop-kit run traces or DEGRADED mode against any document with user-supplied inputs, always producing an advisory DRAFT report that a human must review and approve.

Hipocampus provides persistent agent memory across sessions via a 3-tier auto-compacting architecture that maintains a scannable topic index (ROOT.md) alongside hybrid search capabilities. The system enables agents to proactively recognize connections between past context and new requests without explicit search queries, achieving 21.6x better performance than no memory on implicit context retrieval tasks.

Sloptrim is a local detector for AI-writing patterns that scores the first 262,144 characters of extracted prose from files (up to 512 KB plain text or 4 MB for supported archives) against 71 documented patterns, naming flagged spans for fixing before publication. It uses Python standard library only with no network or model calls, reads 20 file formats including .docx and .epub, and integrates into Claude Code via three hooks (PostToolUse, SessionStart, UserPromptSubmit).

WOZCODE is a Claude Code plugin that replaces built-in file tools with token-optimized alternatives for coding, searching, batch editing, and SQL introspection while reducing session cost. The plugin includes a fast codebase explorer subagent and automatically delegates tasks, with savings tracked via login credentials.

Total Recall is a persistent memory system for Claude Code that saves only behavior-changing facts through a curated write gate, using a tiered architecture of daily logs, structured registers, and auto-loaded working memory. The system prevents memory bloat by requiring saved notes to pass gates about behavioral impact, commitments, decisions, or stable facts—keeping the AI focused on what actually matters across sessions.

Claude Remember hooks into your coding sessions to automatically save, compress, and summarize conversations into tiered daily logs using Claude Haiku. On the next session start, it injects your compressed memory history into context so the agent begins with awareness of previous work, decisions, and lessons learned.

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.

This Claude Code plugin provides 14 curated agent skills for CesiumJS v1.143 development, covering ~551 public symbols across domains like 3D tiles, imagery, terrain, camera control, and spatial math. The skills integrate with Claude Code and follow the open Agent Skills standard for browser-based iteration via Chrome DevTools.

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.

A 14-agent Claude Code plugin that transforms raw code into production-ready systems by handling architecture, testing, security audits, CI/CD, and documentation across a structured DEFINE→BUILD→HARDEN→SHIP→SUSTAIN pipeline. The plugin's Loop Engine ensures agents iterate until convergence against verifiable checks like typechecking, tests, and running application validation rather than stopping at claimed completion.

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.

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.

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.

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.

Bridge compiles natural-language design descriptions into Figma output that is guaranteed design-system compliant by construction, enforcing 26 Figma API rules automatically through a local deterministic compiler. It provides Claude Code skills for iterative design generation (`make`/`fix`/`done`), maintains a synchronized knowledge base of design system registries via cron, and executes designs in Figma through MCP.

Token-Saver is a Claude Code plugin that automatically compresses verbose CLI output from tools like git, docker, npm, pytest, and kubectl using 36 specialized processors, reducing token usage by 60–99% while preserving errors and actionable data. It runs transparently in the background on PreToolUse and SessionStart hooks, providing offline regex-based compression with no LLM calls or configuration required.

This Claude Code plugin enables an autonomous review loop where Claude and code collaborate with adversarial pushback to plan features or audit code interactively in a single window. It provides 6 commands and a stop hook for managing the review cycle.

CodeDNA extends Claude Code with an in-source AI communication protocol that embeds structured annotations (exports, used_by, rules, agent logs) directly in source files across 9 languages and 7 template engines. Four commands (/codedna:init, /codedna:check, /codedna:manifest, /codedna:impact) and four automatic hooks provide architectural context, dependency tracking, annotation enforcement, and inter-agent communication without requiring external service calls.

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`.

Unslop removes AI-characteristic patterns like sycophancy, stock phrases, hedging, and em-dash overuse from Claude output while preserving code, URLs, and technical accuracy. It works as a Claude Code plugin with session hooks that intercept and rewrite text to sound more naturally human.

This plugin automatically formats C# files using CSharpier after Claude writes or edits them, triggered by a PostToolUse hook that respects project-level .csharpierrc configuration. It handles multiple C# file extensions, survives CSharpier version upgrades, and can be disabled via environment variable without affecting other .NET functionality.

This plugin provides a suite of .NET development tools including automatic CSharpier code formatting for C# files, dotnet-run-file for executing C# without projects, and skills for code analysis via Roslyn AST queries, API inspection, and code coverage reports. It hooks into Claude's post-edit workflow to format C# files automatically and exposes 9 skills for inspecting .NET libraries, analyzing code patterns, and diagnosing style violations.

This plugin adds audio feedback to Claude Code on Windows by playing system sounds when Claude finishes responding or when notifications occur using PowerShell. It provides non-blocking background playback and is configurable via environment variables to select different Windows system sounds or disable the feature entirely.

This Claude Code plugin automatically generates and maintains a fractal multi-level documentation system inspired by Gödel, Escher, Bach, creating self-referential PROJECT_INDEX, FOLDER_INDEX, and file-header annotations that keep code and documentation in perfect sync. It uses post-tool hooks to detect code changes and automatically regenerate the interconnected index structure across the entire project.

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.

This Claude Code plugin automatically generates session titles from the first prompt and optionally refreshes them as conversations evolve, using either the local Claude Haiku model or a local Ollama instance. It hooks into the UserPromptSubmit event to capture AI-generated title suggestions and apply them as official session titles.

This Claude Code plugin plays HAL 9000 voice clips at key workflow events like session start/end, tool use, and user prompts, with quotes matched thematically to each moment. It requires python3 and the macOS built-in afplay command, and can be toggled on/off via the /hal-voice-toggle command.

Clay is a plugin that adds 31 skills to Claude Code for building applications, integrated via hooks that monitor tool usage. It requires approval CLI scripts and shell execution capabilities to function.

Vibes is a GUI framework for Claude Code that lets non-programmers build multi-user web apps as single HTML files with embedded TinyBase databases and real-time sync. Users describe their app idea, and Claude generates a complete, deployable application without requiring backend setup or server management.

Governor optimizes Claude Code sessions through tool-output filtering, context compression, and drift guardrails, while also providing prompt-based rules for context hygiene in other AI coding agents like Cursor, Windsurf, and Cline. It maintains decision quality and unique data integrity while reducing token waste from verbose tool output and recurring context overhead.

Alive provides local, user-owned context management for Claude Code, enabling you to keep all your work in files you control on your machine. It integrates through multiple lifecycle hooks and shell execution to maintain persistent session state across tool use and user interactions.

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.

claude-mega-brain injects a compressed OKF-formatted knowledge index into Claude Code sessions automatically, enabling accurate project-specific answers without tool calls. The plugin scans for markdown files with YAML frontmatter type declarations and injects the consolidated knowledge at session start and after tool use.

A comprehensive Claude Code plugin that integrates Remotion with a full suite of video production tools—including video analysis, TTS voiceovers, music/SFX generation, stock footage search, AI image/video synthesis, animated captions, and professional transitions. It automates the entire pipeline from concept to render through MCP servers and command-driven agents powered by ElevenLabs, TwelveLabs, Pexels, KIE, and Replicate.

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.

This Claude Code plugin monitors competitor content across X, Instagram, TikTok, and YouTube to identify high-performing posts and surface actionable content ideas ranked by engagement data. It learns your brand's voice and niche through your own channel analysis, then personalizes idea recommendations while filtering out content you've already made.

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.

Lisa conducts structured interviews about features using AskUserQuestion, capturing answers to generate comprehensive product requirement documents in Markdown and JSON formats. It's designed to automate specification workflows before implementation, with support for resuming interrupted sessions and optional first-principles questioning to challenge assumptions.

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).

This Claude Code plugin provides persistent memory for sessions through a local Honeycomb daemon, enabling Claude to retain context across interactions without external API dependencies. It integrates via lifecycle hooks and an MCP server to automatically save and recall session state.

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.

Double Shot Latte is a Claude Code plugin that intercepts stop attempts and uses a separate Claude instance to intelligently decide whether Claude should continue working instead of asking for permission. It analyzes conversation context to determine if work is incomplete and next steps are obvious, blocking unnecessary interruptions while respecting legitimate stops.

libreuiux-hooks registers three Claude Code hooks that provide UI project context at session start, confirm before editing secret files, and flag accessibility and design issues after UI file edits. The hooks parse stdin JSON with jq and return findings to Claude via the documented hook output format, without requiring file system configuration.

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.

Buddy is a persistent AI coding companion plugin that provides real-time feedback via a PostToolUse hook, maintaining character stats, XP progression, and personality across 21 species stored in local SQLite. It works with Claude Code, Codex, Gemini, Copilot, Cursor, OpenClaw, and other MCP-capable clients to catch reasoning loops and react contextually to your work.

Matrix gives Claude Code persistent memory and deep code intelligence through semantic search and tree-sitter indexing across 15 languages, with hooks for pre-emptive issue detection and code review. Features include solution recall, symbol navigation, CVE warnings, and dead code detection—all stored locally with no external API calls.

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.

This plugin turns a single Claude Code session into a project manager that launches and controls other Claude Code, Codex, or Pi sessions as parallel workers via tmux, monitoring their progress through JSONL event streams. Workers execute tasks independently and concurrently while a controller session assigns work, observes execution, and collects results.

libreuiux-hooks registers three Claude Code hooks that inject UI best practices into your workflow: a SessionStart hook outputs stack context and relevant plugins for frontend projects; a PreToolUse hook confirms before editing secrets files; and a PostToolUse hook highlights accessibility and design issues after UI file edits. All hooks read JSON from stdin and return Claude-formatted context without requiring external APIs or writing files.

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.

research-council orchestrates parallel deep research across Claude Code and OpenAI's Codex CLI, running each agent independently on a research topic with web search iteration, then performs cross-pollination refinement where each agent reads and responds to the other's findings before synthesis. The plugin coordinates a three-phase pipeline—independent research, cross-pollination, and final synthesis—to produce research substantially deeper than any single agent could achieve alone.

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.

Bedrock automates Obsidian vault management by turning markdown notes into a structured knowledge graph with AI-powered entity detection, bidirectional linking, and sync across 7 entity types. It ingests external sources (Confluence, Google Docs, GitHub, PDFs, and more), deduplicates content, and provides orchestrated querying through Claude Code skills.

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.

AutoCode is a 47-skill Claude Code plugin powered by I-Lang v3.0 that automates the entire development-to-deployment pipeline in a single session, requiring only natural language instructions and bash. It handles server setup, application building, and live deployment with zero external dependencies, making full-stack development accessible to non-programmers.

great_cto orchestrates a pipeline of 69 specialist agents that design, build, review, and deploy full-stack applications with two human approval gates. Users describe a product once, approve the architecture, then approve the deployment while agents handle all intermediate stages including backend, frontend, testing, code review, and security.

Pith automatically compresses Claude Code tool outputs (file reads, bash runs, grep results) by 40–60%, tracking token usage with a status dashboard and enforcing context ceilings via hooks. It includes a self-building project wiki, symbol extraction, URL ingestion, and structured output modes that escalate from lean to ultra as context fills.

This Claude Code plugin intercepts the agent's plan-writing mode and opens a local browser UI where you can annotate plans with strikethroughs, replacements, insertions, and comments before approving or requesting revisions. All processing runs locally with no external service dependencies, and the agent iterates on your feedback until the plan is approved.

jevmem automatically captures and summarizes important context from your Claude Code sessions into a JEVMEM.md file in your repository, then injects relevant memory lines back into your prompts on each new message. It uses hooks to intercept prompts and turns, optionally condensing them via TypeSafe's Jev API before storing them as single-line entries.

This Claude Code plugin integrates oxlint-tailwindcss linting into the editor, providing real-time diagnostics as Claude edits files and running a final lint check before completion. It includes an LSP server for inline diagnostics, hooks to capture and validate edits, and a setup skill.

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.

The WakaTime plugin for Claude Code tracks AI usage, lines of code generated, and time spent prompting through hooks into Claude's tool execution and session lifecycle. It integrates with the WakaTime dashboard to provide coding activity metrics and insights based on AI-assisted development.

This is a retired plugin that has been superseded by OpenAI's official Codex plugin. The plugin displays a migration notice on startup and should be uninstalled in favor of the official offering.

This plugin provides four development workflow skills for planning, implementing, and containerizing cloud-native applications: a PRP generator for writing Product Requirement Plans with validation gates, an executor for driving feature implementation, a containerizer for modern Docker multi-stage builds and Compose setup, and a fifteen-factor app architecture reviewer. It integrates with GitHub and automatically picks up skills during sessions to guide development lifecycle decisions.

The Documents Toolkit plugin provides fast PDF text extraction, OCR for scanned PDFs, and structured parsing of PDFs and office files (DOCX, PPTX, XLSX, ODF, EPUB, email) into JSON and markdown. It includes uv-runnable scripts for PDF forms, table extraction, merging, splitting, and validation—all with zero local installations via uvx and inline dependencies.

This plugin is retired; Gemini CLI stopped serving individual accounts on 2026-06-18 and has no official Claude Code replacement. Users should uninstall it and refer to MIGRATION.md for alternatives.

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.

This plugin is retired and has been superseded by Cloudflare's official plugin for the same server, along with dedicated Workers and Wrangler skills. It now contains only a startup notice directing users to uninstall it and migrate to the official alternative.

This plugin connects Claude to CoinGecko's API for querying cryptocurrency prices, market data, and historical trends through read-only tools. It runs as an MCP server and prompts for a free demo API key on first use, storing it securely in the system keychain.

This plugin is retired and no longer functional; the built-in WebFetch tool in Claude Code replaces it. Users should uninstall this package and use Claude Code's native web-fetch capability instead.

This plugin is retired and no longer functional; Gemini CLI stopped serving individual accounts on 2026-06-18. Users should uninstall it and refer to MIGRATION.md for alternatives.

mcp-google-workspace integrates Google Workspace services (Gmail, Drive, Calendar) with Claude Code via an MCP server that uses OAuth authentication to provide workspace access. The plugin handles OAuth credential management through Claude Code's prompts and securely stores credentials in your system keychain.

This plugin enables Claude Code to manage MikroTik routers and automate network operations over SSH by hooking into session startup to prompt for router credentials. It wraps the mcp-server-mikrotik MCP server, storing the password securely in your system keychain and passing credentials via environment variables.

This Claude Code plugin integrates n8n workflow automation by exposing n8n workflows and executions through an MCP server. It requires an n8n instance URL and API key, stored securely in your system keychain, and launches via an MCP server that hooks into Claude Code's session start.

This plugin has been retired because Notion publishes an official plugin for the same server; the final version only displays a startup notice directing users to uninstall and migrate to the official Notion plugin. Users should run `claude plugin uninstall mcp-notion@wookstar-claude-plugins` and install the official version instead.

This MCP plugin integrates Perplexity AI's search and information retrieval capabilities into Claude Code via an MCP server. It prompts for your Perplexity API key on first use and stores it securely in your system keychain.

This Claude Code plugin provides comprehensive Shopify development reference documentation covering Liquid templating, Online Store 2.0 themes, Hydrogen framework, app development, and Functions, while deferring live GraphQL schema validation to Shopify's official tools. It includes reference materials on theme performance, debugging, API versioning, and migration guidance for deprecated features like Scripts and Hydrogen API changes.

Ship is an agentic development harness that routes Claude or Codex through mechanically enforced quality gates—from raw requirements to green PR—making failure modes like skipped tests and unvalidated code structurally impossible. It provides 11 atomic skills (design, dev, E2E, review, QA, refactor, handoff, and more) that work standalone or as a full staged workflow with isolated phases, disk-resident state, and hierarchical evidence requirements.

This Claude Code plugin enforces a security boundary around a project directory, allowing destructive file operations (rm, mv, cp, etc.) and file edits within the project while blocking them outside. It uses bash hooks to parse and validate commands before execution, handling edge cases like symlinks, cd tracking, command substitution, and variable expansion.

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.

This Claude Code plugin automatically routes prompts to the most appropriate Claude model based on detected complexity, using hooks to intercept user inputs and tool usage. It requires only Python 3 and no external API keys, making it a lightweight addition to Claude Code workflows.

The envault plugin intercepts tool calls via a PreToolUse hook to substitute secret aliases and ciphers into plaintext values, keeping sensitive data encrypted until the moment of use. It pairs with the envault CLI and the guard.sh external tool to provide a secrets vault workflow that avoids storing plaintext credentials.

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.

winnow is a context optimization plugin for Claude Code that intelligently filters large tool results (Read, Bash, Grep) by using a fast System One model judge to identify irrelevant blocks, replacing them with summaries and recall keys to save tokens. The plugin operates as a function hook that intercepts tool results before they enter Claude's context, allowing full text to be recovered on demand while keeping the conversation focused on what matters.

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.

A hook-based delegation system that routes Claude Code tasks to 8 specialized agents with support for both isolated subagent workflows and collaborative Agent Teams, using adaptive soft-enforcement nudges and intelligent dependency analysis for parallel or sequential execution. The system enforces structured task decomposition through plan mode, with lean SessionStart injection, task tracking via Tasks API, and real-time inter-agent communication for multi-step workflows.

Funnel Architect transforms Claude into a full-stack sales funnel architect, generating production-ready pages, conversion copy, and deploying to Vercel, Netlify, or Cloudflare using 5 specialist agents and 29 skills covering 13 funnel types. It automates strategy, design, copywriting, performance optimization, and deployment with integrated payment processing via Stripe.

Claude Code Achievements is a gamification plugin that tracks your Claude Code skill progression through 29 Steam-style achievements organized across 4 skill trees, triggering real-time notifications when you unlock milestones. It hooks into Claude Code's event system to monitor tool usage and automatically detects achievement conditions, with progress saved locally to ~/.claude/achievements/state.json.

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.

This Claude Code plugin sends telemetry data from Claude Code sessions to PostHog LLM analytics via a session-end hook. It provides LLM usage tracking and session analytics without requiring external API keys.

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.

Claude Gladiator hooks into tool execution to observe failure patterns and prompt reflection before session ends, using an MCP server to cluster observations into learning recommendations. It runs silently on success and only processes errors, with minimal token overhead (~100-200 per session).

Claude Historian automatically searches past sessions before web research, planning, and debugging to avoid redundant work. It uses an MCP server to inject history-checking logic at key decision points, reusing prior solutions and decisions when available.

Claude Oracle automatically discovers skills, plugins, and MCP servers across 17 community sources by searching at high-impact moments like planning and error recovery. It integrates via hooks that trigger search before planning and after errors, returning install commands for immediately relevant tools.

Claude Orator is a prompt optimization coach that deterministically scores and restructures prompts using Anthropic best practices without making LLM calls or network requests. It runs as a PreToolUse hook to suggest improvements for under-specified subagent prompts and includes a command for manual prompt optimization across 7 dimensions (clarity, specificity, structure, context, examples, constraints, tone).

Claude Praetorian automatically preserves conversation context by prompting to save and restore valuable context at strategic moments—before planning, after research, and when subagents complete. It integrates with an MCP server to manage context compaction and restoration across Claude Code sessions, reducing token usage by 50–60%.

Claude Vigil creates file checkpoints before destructive bash operations (rm, mv, git reset) and provides tools to diff changes and restore files safely using content-addressable storage. Commands and MCP tools let users manually save named snapshots and restore from them on demand.

This plugin teaches Claude to prefer the iq CLI for agent-native workspace search over grep/find/Glob, and adds session recall capabilities to retrieve past-session files by topic and fork sessions mid-conversation. It ships as a skill with SessionStart and UserPromptSubmit hooks that automatically suggest features like past-session topic→file search and mid-point session forking based on matching first prompts.

This Claude Code plugin provides comprehensive Jira integration through two specialized skills: jira-communication for API operations via Python CLI scripts, and jira-syntax for wiki markup and validation. It auto-discovers issues from context, works with both Jira Server/DC and Cloud deployments, and requires only Python 3 with no external API keys or MCP overhead.

This plugin analyzes Shen Lun (申论) examination materials, provides corrective feedback on responses, and assigns structured scores while enforcing safe execution. It integrates Python3-based processing through an MCP server and a PreToolUse hook for validation.

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.

Zero Drift is a Claude Code skill that maintains grounded AI behavior across long sessions by requiring replies to open with your name and maintaining a living TASK.md document that records proven work and current state for seamless context handoffs. When sessions degrade, you can resume from a fresh window by reading the TASK.md file, avoiding repetition and context drift.

MLflow Skills equips coding agents with observability, debugging, and evaluation capabilities for GenAI applications through tracing, trace analysis, and quality measurement. The plugin includes an optional UserPromptSubmit hook that auto-suggests relevant skills when MLflow-related patterns are detected in prompts.

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.

A Claude Code plugin that plays contextual Mr. Meeseeks voice lines whenever Claude finishes a task and is waiting for your next prompt or needs your approval. It uses the Notification and UserPromptSubmit hooks to detect idle/permission scenarios and plays curated audio clips from categories (done, asking, feedback) without blocking your workflow.

Wenlan is a living knowledge base that agents build during work sessions, with learned insights automatically converted into source-cited wiki pages that persist across threads. Each new session starts with the latest accumulated knowledge from previous agent work.

Wenlan is a local-first knowledge base that agents build autonomously as they work, capturing learnings as source-cited wiki pages that persist between sessions. All data lives on your machine under ~/.wenlan, with memories and pages served by a local daemon that never shares content with Anthropic or external services.

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.

lintlang audits agent configs, system prompts, and tool definitions by scanning YAML, JSON, Markdown, and Python files, offering both an on-demand audit skill and automatic repair guidance after Claude Code edits supported language-bearing files. The plugin requires Python 3.10+ with lintlang installed via pipx, runs the scanner locally without making network calls, and integrates with Cursor's Agent Plugins in addition to Claude Code.

Wenlan is a living knowledge base that agents build and maintain as they work, automatically creating source-cited wiki pages that persist between sessions and refresh with new discoveries. Each new thread starts from the latest accumulated knowledge, allowing agents to leverage previous learnings and context.

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.

A toolkit that scaffolds and retrofits AI-agent-friendly projects with enforcement hooks, config templates, and engineering patterns, including a self-improvement loop that learns from project usage to propose better rules over time. The plugin installs 8 skills for project setup and management plus 9 hooks for safety enforcement and signal capture.

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.

This Claude Code plugin enforces git safety rules (blocks force-push and direct pushes to protected branches) and provides autonomous skills for debugging and merge-conflict resolution. It injects prose-rule templates into projects and runs optional bash-level guards at strict enforcement profiles.

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.

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.

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 Claude Code plugin that enforces git safety and dev discipline for unattended agents through configurable hooks, prose rules, and hard bash-time blocking of force-push, --no-verify, and direct pushes to protected branches. It includes autonomous skills for debugging workflows and resolving merge conflicts, plus an instruction template (CLAUDE-APPEND.md) that applies consistent rules across all code-writing agents in a project.

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.

Fable Orchestrator routes multi-agent work across Claude Fable 5 (planning), Sonnet 5 (volume), and Opus 5.5 (hard tasks) to minimize Fable token consumption, with automated spawn management and a strict output cap. The plugin uses hooks to delegate by default, enforce per-worker visibility in tmux, and deny unnamed spawns while allowing the chair to remain focused on planning and arbitration.

Summer SDK provides 78 game-dev skills, lifecycle hooks, and a 62-tool MCP bridge that connects AI agents to the Summer Engine for building real 2D and 3D games through conversation. The plugin integrates with Claude Code, Cursor, Codex, Devin Desktop, and other AI agents through a single npm package with MIT open-source tooling.

ballast is a Claude Code plugin that helps you build expertise in unfamiliar domains by decomposing goals into foundational steps, then preserves solved paths and rules as persistent knowledge that carries forward to subsequent goals. It delivers standing rules and verified facts into conversations via four hook events (UserPromptSubmit, PreToolUse, PreCompact, SessionStart) and provides sixteen markdown skills for decision tracking, verification, goal decomposition, and knowledge management.

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.

guardrails is a PreToolUse hook that prevents destructive Bash commands during Claude Code execution by hard-blocking catastrophic operations like rm -rf / and docker volume rm, while allowing safe deletions within the workspace scope after confirming ambiguous cases. It inspects normalized command syntax with heredocs and comments stripped, making it effective against accidental or malicious filesystem damage without impeding legitimate development work.

A Claude Code plugin that scaffolds and maintains a `docs/lore/` directory to capture implicit project knowledge—business rules, API quirks, pitfalls, and decision rationale—that code and git history can't reveal. Seven interlinked skills (init, consult, capture, guard, maintain, check, ul) form a self-correcting loop: capture knowledge as you learn it, consult it before acting, guard diffs against it at commit time, and health-check the lore every ~30 days to keep it alive.

Codemem provides persistent memory for Claude Code by capturing work across sessions through hooks that trigger on session and tool events. It lets you recall relevant context from previous interactions to maintain continuity and context awareness during code development.

This stop hook evaluates Claude's final answer against the turn's tool output using TypeSafe's Jev decision model to detect unsupported claims, then sends Claude back to re-check if hallucinations are detected. It integrates with the grounded-ai Python library to provide hallucination detection and fact-checking with optional fallback to LLM judges like Claude, GPT, or local models.

This Claude Code plugin sets up an experimental local subscription gateway proxy that intercepts and manages Claude API traffic through setup and disable commands. It operates independently of tracing and hooks into session lifecycle events and user prompts to monitor subscription usage.

This Claude Code plugin traces conversations, tool calls, subagent executions, and context compaction events to LangSmith for observability and debugging. It integrates via 7 hooks into Claude Code's execution lifecycle and requires Node.js v18+ to run.

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.

This plugin integrates Pinecone's vector database directly into Claude Code through an MCP server, enabling semantic search, RAG workflows, and index management. It provides slash commands for quick operations, support for Pinecone Assistants for document Q&A, and access to core Pinecone tools like index creation, upserting, and querying.

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.

peepshow converts videos, animated GIFs, APNGs, and WebPs into extracted frame sequences, audio tracks, and transcripts that Claude can analyze as images and audio. It integrates with Claude Code via drop-and-drop support and provides pluggable sink backends to route extracted content to 95+ downstream systems including storage, databases, chat platforms, and analytics services.

This Claude Code plugin grounds all RuvNet-related decisions in real source code from 77 RuvNet repositories, injecting retrieval-augmented generation via a search_ruvnet tool and hooks that enforce grounding before RuvNet product code is used. It ships 6 commands, 9 skills, 12 hooks, and 1 MCP server to steer Claude toward Ruflo, RuVector-RVF, and AgentDB instead of training-prior defaults like pgvector and Pinecone.

total-agent-memory provides persistent, local memory for Claude Code and other MCP clients through a temporal knowledge graph, procedural memory system, and AST codebase ingest that tracks facts, decisions, and working practices across sessions. It installs as an MCP server with capture hooks that fire on session start/end, tool use, and user input to build and query a searchable local-first knowledge base with optional grounded retrieval and revision history.

This plugin opens a video chat with a random stranger while your Claude is processing a task, closing automatically when either Claude finishes, without sharing any task details. It uses bash hooks to send only anonymized telemetry (token, session hash, event type) to a lobby server while keeping audio/video communication peer-to-peer.

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.

This Claude Code plugin enables peer-to-peer communication between separate Claude Code sessions running on the same machine through shell commands and hooks. It uses a SessionEnd hook to manage communication state and coordinate data exchange between concurrent sessions.

Toonify MCP automatically compresses large tool output—JSON, YAML, stack traces, and logs—before it enters Claude Code's context window, reducing token usage without breaking workflows. It runs as a zero-config Claude Code plugin or optionally as an MCP server or pipe filter for any agent CLI.

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.

This Claude Code plugin provides optional game development safety hooks that detect popular game engines (Godot, Unity, Unreal, web frameworks) and remind you of the project type, require confirmation before touching secrets/signing keys/destructive Git commands, and notify when written files are empty or when tests should be run. It operates through three shell scripts triggered on session start, before tool use, and after write operations.

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.

A Claude Code plugin that routes Siemens TIA Portal engineering automation tasks to 19 specialized skills covering Python TIA Scripting V1.4.3, C# Openness API domains, Modular Application Creator workflows, and Add-In development. It includes MCP write-safety hooks, diagnostic tools, and integrates with TIA Portal V21 via an MCP server for direct interactive automation.

ClawCode extends Claude Code as a persistent agent plugin, adding memory, personality, voice, and messaging across WhatsApp, Telegram, Discord, iMessage, and Slack with bilingual recall and lifecycle hooks. It runs entirely within Claude Code's plugin system with no separate billing, featuring nightly memory consolidation, slash commands, webhooks, and an optional always-on background service.

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.

claude-mem-lite is a persistent memory system for Claude Code that automatically captures coding decisions, bugfixes, and context across sessions using MCP hooks and stores them in a single SQLite database with FTS5 full-text search. It achieves 7-10× fewer LLM calls and ~600× lower estimated cost than the original claude-mem by batching episodes and using a smaller model, with zero external services.

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.

A gamified productivity companion that spawns Pokémon battles in a separate terminal while you work in Claude Code, with encounter frequency tied to prompt length and Claude's processing time. The entire game runs locally with the original 151 Pokémon, requiring no backend or external services.

Eidos enables spec-driven development in Claude Code by treating Markdown specifications as the source of truth, with code as a downstream manifestation that stays bidirectionally in sync. It provides 73 skills organized around core workflows—spec↔code loops, persistent planning and memory, research and understanding, and steering mechanisms—to keep human intent and AI reasoning aligned throughout development sessions.

AgentLint evaluates repository harnesses (context files, CI config, instructions) used by AI coding agents, scoring them across six core dimensions with 58 deterministic checks. It offers both a CLI tool and Claude Code plugin with guided fixes and evidence-backed recommendations to improve agent reliability.

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.

Agent Reachout sends notifications to Telegram when Claude Code agents finish tasks, hit blockers, or need decisions, enabling asynchronous human-in-the-loop workflows without terminal monitoring. It supports one-way notifications or two-way conversations, allowing agents to pause, ask questions, and resume execution based on human input.

context-guru intercepts and optimizes Claude Code sessions through a local proxy, reporting token and latency savings achieved. It installs as a reversible proxy layer with hooks into session start and prompt submission, using shell scripts to manage the proxy lifecycle.

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.

oh-my-fable automatically injects Anthropic's Claude Fable 5.1 prompting guidelines into Claude Code sessions via a SessionStart hook, with optional commands to transform rough requests into structured prompts and audit rule compliance. The plugin detects session type (interactive vs. unattended) and subagent contexts to apply appropriately scoped versions of the Fable 5.1 guidance without creating or modifying user files.

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.

cc-suite is a Claude Code plugin that synchronizes instructions, skills, hooks, and MCP servers across Claude Code, Codex CLI, and Antigravity CLI, enabling bidirectional delegation between them and optional integration with Grok Build, Qwen Code, opencode, and Kimi CLI. It provides 45 commands and 13 skills to manage single-source AGENTS.md files, shared skill trees, mirrored hook events, and bounded code review through Qwen or delegation to Grok.

A production-ready prompt library of 35+ specialist prompts covering the APEI cycle, task-routing, and reference hooks for Claude Code agents, Skills, MCP, Plugins, and subagents. The plugin includes six operational skills (find-prompt, deterministic-checks, changelog-from-commits, doc-link-audit, skill-audit, capability-audit) and two deterministic safety hooks that block destructive commands and credential writes.

This plugin maintains a searchable local index of Claude documentation accessible via the /docs command and auto-discovery skills. It automatically updates the documentation on session start and provides instant access to API references, guides, and tutorials without external service dependencies.

A 37-skill agent that operates the entire Oracle AI Data Platform (AIDP) Workbench in natural language, discovering catalogs into a grounding cache and turning English into accurate Spark SQL for the full lakehouse lifecycle (DDL/DML, pipelines, clusters, debugging). It extends data engineering with AI governance (roles, credentials, Delta Sharing, audit logs) and ships guarded AI through Agent Flows, Knowledge Base RAG, and LangGraph agents, plus signature differentiators like LLM-in-SQL via ai_generate() and cross-source federation.

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.

This plugin provides expert guidance on Git workflow best practices, including branching strategies (Git Flow, GitHub Flow, trunk-based), commit conventions, collaborative workflows, and CI/CD integration with built-in commit validation hooks. It includes a `/pr-finish` command that automates pull request merging by preflight checking, rebasing, fixing CI, and resolving review threads.

Hush is a Claude Code plugin that reduces narrative output and tool verbosity through writing-style controls and session hooks, shortening final answers to focus on results. It trims command output, references full results when needed, and supports customizable voices while maintaining correctness and completeness.

This Claude Code plugin installs three safety hooks for firmware development that prompt for confirmation before flash/erase operations and secret-file access, detect embedded projects at session start, and flag empty files after edits. It integrates with Claude's tool-use pipeline using bash scripts to filter operations without requiring external services.

This Claude Code plugin adds optional safety hooks for firmware development workflows, requiring confirmation before flash/erase operations and sensitive file access, while detecting embedded projects at session start and flagging empty files after edits. It intercepts tool use events via bash scripts that parse JSON input without requiring external services or API keys.

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.

This plugin integrates Claude Code with macOS's native caffeinate command to prevent system sleep during coding sessions. It activates automatically when a session ends to ensure continuous workflow without interruptions.

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.

ArmorClaude is a Claude Code plugin that enforces intent-based security by intercepting user prompts to capture a declared plan, then verifies every tool call against that plan before execution and logs all actions for audit compliance. It supports policy-based access control with data classification rules (PCI/PII), optional CSRG cryptographic proofs, and runs in a fail-closed mode where all tool calls are blocked if planning, identity, or token verification fails.

Mycelium enforces a structured discovery phase before code generation by asking clarifying questions about purpose, assumptions, and validation criteria, then gates the build until answers are provided through 63 skills and 15 theory gates wired as hooks. The plugin installs brownfield-safe without modifying existing project files, shipping versioned capabilities via Claude Code's plugin mechanism.

This Claude Code plugin automatically distills reusable techniques from complex tasks into a SKILL.md library and implements a self-improving loop where the plugin learns and refines its own skills across sessions. It uses hooks (PreToolUse, PostToolUse, SessionStart, Stop), agents for skill review and curation, and shell commands to manage a persistent skills store with validation, deduplication, and time-based archival.

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.

Makoto is a verification plugin that audits Claude Code agent behavior against logged records, blocking fabricated tool checks while allowing sixteen legitimate advisory self-checks. It enforces integrity across two-tier catalogs of 17 pre-checks and 30 stop gates, all calibrated to zero false positives.

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.

KRouter is a Claude Code plugin that provides shared agent memory backed by plain Markdown files in Obsidian, allowing agents to cite sources and refuse to guess when information is unavailable. It integrates with Claude Code, Codex, Cursor, and DeepSeek through MCP, automatically imports session history, and keeps an indexed vault that multiple agents can query and update.

This plugin automatically enhances prompts with composable decorators (reasoning, structure, tone, verification, etc.) via a UserPromptSubmit hook, slash commands, and an optional Haiku-powered auto-selector. It vendors the prompt-decorators engine with 140+ decorators across ~14 categories, allowing decorators to be applied inline with `::Name(params)` syntax, configured persistently, or selected automatically based on prompt content.

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.

Vitals scans a codebase to identify high-risk files by analyzing churn, complexity, and coupling, then uses Claude to diagnose root causes and recommend fixes ranked by ROI. It runs locally with no dependencies or API keys, silently tracking AI-generated edits via PostToolUse hooks to reveal automation patterns over time.

This plugin provides 13 skills for coding agents to query data and build semantic models through the Honeydew MCP, enabling natural-language questions about metrics, entities, and warehouse data. It integrates with multiple coding agents including Claude Code, Codex, and GitHub Copilot CLI to help users explore semantic layers, create business concepts, and analyze anomalies.