Project Management plugins for Claude Code

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.

Hermes Agent is a self-improving AI agent by Nous Research with a built-in learning loop that creates and improves skills autonomously, supports multiple LLM providers, and runs on any infrastructure from a $5 VPS to serverless platforms. It offers a real terminal interface, multi-platform access (Telegram, Discord, Slack, WhatsApp, Signal, CLI), scheduled automations, parallel subagent delegation, and cross-session memory with full-text search.

gstack is a comprehensive AI agent skill suite that transforms Claude Code into a virtual engineering team with 56 specialized skills spanning product review, design, security audits, testing, documentation, and deployment. Each skill is available as a slash command and automates workflows like CEO review, design consultation, code security audits, QA testing with real browsers, and release engineering.

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.

OpenSpec is a specification framework for planning and implementing features with AI using a structured artifact workflow that keeps teams aligned across repos. It provides skills for exploring ideas, proposing changes, implementing tasks, verifying work, and archiving completed features with auto-generated requirements and design docs.

An AI-powered job application framework with three agent skills—scrape job portals, evaluate fit, and draft tailored applications—that runs on Claude Code to automate job search workflows. The system profiles your background, searches local job boards, and guides applications through a drafter-reviewer pipeline with optional interview preparation and salary benchmarking.

OpenMAIC is an open-source multi-agent platform for building immersive interactive courses in one click, featuring a Pro workbench for agent-guided curriculum planning, course generation, and revision with 24 built-in skills covering slides, quizzes, interactives, and media. It runs on Next.js, React, LangGraph, and neutral provider architecture, supports local AI via Lemonade, and integrates with OpenClaw agent workbenches.

This Claude Code plugin integrates Linear issue tracking by connecting to Linear's MCP server, enabling creation of issues, project management, status updates, and workspace searches directly within Claude. It streamlines software development workflows by exposing Linear's core issue-tracking capabilities through a unified interface.

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

This plugin turns Claude into a customer support co-pilot for ticket triage, multi-source research, response drafting, escalation management, and knowledge base authoring. It integrates with Slack, Intercom, HubSpot, Guru, Notion, and Atlassian to synthesize customer context and automate support workflows.

The Engineering plugin streamlines software engineering workflows—standups, code review, architecture decisions, incident response, and technical documentation—working standalone or integrated with tools like GitHub, Linear, Jira, Datadog, PagerDuty, and Slack. It provides six explicit slash commands and six domain skills that automatically assist with engineering tasks, from pull request reviews to production incident triage and postmortem writing.

This plugin streamlines finance and accounting workflows including journal entry preparation, account reconciliation, financial statement generation, variance analysis, and SOX audit support. It integrates with data sources via MCP servers (ERP, data warehouse, spreadsheets, BI tools) and plugs into BigQuery and Slack for data access and team communication.

This HR plugin streamlines recruiting, onboarding, performance reviews, compensation analysis, and policy guidance through 9 domain skills and 6 MCP integrations (HRIS, ATS, compensation data, Slack, calendar, email). It works standalone with manual input or supercharged when connected to your existing HR systems like Workday, Greenhouse, or BambooHR.

This plugin helps ops teams manage vendor relationships, document processes, handle change requests, plan capacity, track compliance, and generate status reports—all through slash commands and domain-specific skills. It works standalone with manual input and integrates with Asana, Jira, Notion, Slack, and other ITSM and project management tools for richer context.

This plugin gives Claude persistent task management, workplace memory, and a visual dashboard that syncs with external tools like Slack, email, calendar, Notion, and project trackers (Asana, Linear, Atlassian, monday.com, ClickUp). Claude learns your team, projects, and terminology to act as a collaborative colleague rather than a chatbot.

A sales plugin with 36 skills that integrates with CRMs, email, calendar, chat, and call recorders to help teams prep calls, research accounts, review deals, and manage pipeline and forecasting. It works across multiple vendors (Salesforce, HubSpot, Close, Outreach, etc.) and can update CRM records, draft emails, post to chat, and book meetings when requested.

A comprehensive small business plugin with 44 pre-built skills for finance, sales, marketing, operations, and hiring, integrated with 35+ business tools including Mailchimp, QuickBooks, HubSpot, Stripe, and others. Every action requires explicit user approval before sending, posting, or processing payments.

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.

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

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

firstmate is an agent distribution system that lets you dispatch and supervise a crew of autonomous coding agents from a single conversation, each running in isolated git worktrees with task-specific instructions and reporting outcomes back to you. It integrates with supported agent harnesses (Claude Code, Grok, Pi, Cursor, etc.) and provides visible session backends (tmux, Herdr, Zellij, Orca) to coordinate parallel work on fixes, investigations, audits, and PRs across your projects.

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.

CCX is a standalone Agent Skill pack for managing AI API proxy deployment workflows in Claude projects, with four skills covering model registration, Windows Store publishing, upstream version tracking, and semantic versioning. The skills automate updates to routing configuration, MSIX validation and Store announcements, upstream change detection with TODO generation, and git-based version bumping with auto-generated changelogs.

This Agent Skill enforces completion discipline for substantial autonomous work by requiring acceptance criteria written before execution, breaking down tasks using a Depth Tree, and verifying evidence before reporting results. It uses runnable gates—shell commands with expected outputs tracked in a ledger—to prevent half-done work and ensure auditable checkpoints across long or parallel tasks.

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

This plugin automates changelog generation by collecting recent changes from GitHub, Slack, and Git, synthesizing release notes, validating structure/quality, and preparing a PR. It uses a hybrid Skill + MCP workflow with three commands for validating and generating weekly or custom-date-range changelogs.

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.

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.

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.

This plugin provides DAG-based workflow orchestration with 4 MCP tools that enable users to define, execute, and track complex multi-step workflows with dependency management and parallel task execution. It requires Node.js and offers features like real-time status monitoring, comprehensive run history, and graceful error handling.

A collection of 65 agent skills covering business strategy, marketing, UX design, and software architecture from bestselling books and industry frameworks, plus 14 metaskills that guide users through creating, improving, or growing businesses, websites, and apps. Each metaskill orchestrates constituent skills phase by phase, asking decision questions and persisting state in a project's docs/ folder so journeys survive across sessions.

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.

A community-built library of 93 Claude Skills across product management, marketing, engineering, data, design, Figma, leadership, legal, finance, HR, sales, operations, and research—installable as standalone Agent Skills that teach Claude how to produce professional-grade outputs for specific workflows. No external API keys or paid services required; runs locally after installation.

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.

oh-my-agent (oma) is a vendor-agnostic harness that adds a team of 12 specialist roles to coding agents like Claude Code, Cursor, and Codex, coordinating them through 21 workflows and 33 skills for complex tasks like planning, building, reviewing, and debugging. It integrates with your project's conventions and scripts, maintaining portable `.agents/` configuration across 14 runtimes and supporting research, content generation, and workflow verification gates.

An agent plugin that connects Claude Code to the cq shared knowledge commons, enabling agents to query, propose, confirm, and flag collective knowledge units during coding work. The plugin bundles an MCP server, a core protocol skill, and session commands to help prevent rediscovering the same failures across projects and teams.

This plugin provides secure access to Atlassian products including Jira, Confluence, Jira Service Management, Bitbucket, Compass, Loom, and Rovo through the Model Context Protocol. It enables searching and creating Jira issues, accessing documentation, managing sprints, and integrating development workflows with Atlassian's collaboration tools.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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

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

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.

This Claude Code plugin connects to monday CRM via the official MCP connector to manage sales pipelines entirely in natural language. It offers 9 skills for deal briefings, forecasting, meeting-to-deal logging, workspace setup, and data cleanup—with all results written directly back into monday boards, dashboards, and docs.

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.

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.

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.

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.

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.

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.

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.

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.

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

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.

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.

nonstop lets Claude work autonomously while the user is away by activating a pre-flight risk assessment, dangerous-ops approval system, and intelligent blocker handling framework. When Claude encounters obstacles, it solves problems, works around them when safe, or marks tasks blocked—without spinning or taking unapproved destructive actions.

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

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.

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.

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.

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.

This Claude Code plugin hooks into your coding agent's lifecycle to automatically save, compress, and inject session memory across multiple time horizons—from current buffers to daily and weekly summaries. On each session start, it loads your agent's prior context without manual prompting, giving continuous recall of what was learned, what broke, and what worked.

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

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.

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.

Skills Updater scans installed Claude Code skills across multiple sources (Claude plugins and npx skills) for available updates, supports batch or individual marketplace updates with intelligent change merging, and recommends popular skills from skills.sh and skillsmp.com. The skill detects the user's language environment to provide updates and discovery recommendations in Chinese or English.

Caliper is a lightweight evaluation harness for agent skills that measures success rates by running specs repeatedly against Claude Code, Codex, Pi, or Hermes. It supports three types of checks—LLM-judged expectations, Python assertions, and skill activation assertions—and can ablate skills to measure their marginal contribution.

Hindsight is a self-improvement skill that reviews an entire coding session to extract durable process lessons (not one-off specifics) and saves them as persistent memory, updating existing related entries rather than duplicating them. It works with any AI assistant that has file-based persistent memory, requires no API keys or external services, and is triggered on-demand to avoid automatic writes to memory.

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.

Compass is a local-first Rust workbench that analyzes codebases to generate architecture maps, dependency paths, impact analysis, and Git history—powers the compass-release skill for coordinating Compass version bumps, release PRs, and cross-platform artifact builds via a gated workflow.

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

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.

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.

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.

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.

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.

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.

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.

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

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.

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.

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.

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.

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

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

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

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

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

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.

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.

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.

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.

This Agent Skill systematically addresses GitHub pull request review comments by fetching threads via the GitHub CLI, creating tracked tasks for each comment, and applying fixes with mandatory resolution verification to ensure no comments are missed. It blocks PR completion if any review threads remain unresolved, providing end-to-end accountability from comment to explicit resolution.

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.

This skill provides comprehensive ZFS pool management for homelab environments, including health monitoring, snapshot automation via Sanoid, and pull-based replication across 5 devices using Syncoid. It handles pool properties, performance optimization, scrub scheduling, and troubleshooting workflows without requiring external APIs or paid services.

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.

PM Copilot is an AI-native operating system for product managers offering 65+ embedded PM skills across 12 domains, 17 command-based workflows, and 8 specialized sub-agents that integrate live with GitHub, Jira, Linear, Notion, and Slack. It maintains persistent user memory and executes end-to-end product operations including PRD writing, discovery, strategy review, roadmapping, and launch planning without requiring re-briefing.

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.

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.

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.

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.

Monocle is a terminal UI that enables real-time code review of AI agent output with line-level comments and structured feedback submission. The agent skill set integrates with Monocle to allow agents to send plans for review and retrieve reviewer feedback through a blocking or non-blocking workflow.

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

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.

Lytskill is a suite of 14 Agent skills designed for TikTok Shop and cross-border e-commerce operations, decomposing vague business problems into diagnostic questions and transforming product data into actionable strategies. It helps users clarify traffic logic, validate products, generate and optimize product titles, diagnose listing pages, create detail pages and video scripts, and analyze data across the full e-commerce workflow.

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.

Molten OS Core is a suite of 6 AI agent skills that compress product validation, brand strategy, design systems, and landing page creation into a reusable pipeline—turning a raw idea into a testable landing page in an afternoon. Each skill (molten-validate, molten-brand, molten-design, molten-landing, molten-search, molten-skill-manage) runs in sequence to guide users through discovery, positioning, visual design, and conversion optimization.

This Agent Skill repository provides four release automation workflows for HyperWhisper, a cross-platform speech-to-text application: linux-release, macos-release, windows-release, and localisation-syncer. The skills orchestrate version bumping, release note generation from git history, GitHub Actions triggering, and verification of published binaries across all three platforms plus localization synchronization.

FutureSearch forecasts probabilities, dates, and numeric outcomes for questions about the future and the results of decisions, while also running web research agents. It connects as an MCP server to Claude Code and other assistants, or can be used directly via the Python SDK with an API key.

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.

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 Claude Code plugin bundles the official Airtable MCP server, enabling Claude to work with Airtable bases, records, and schemas directly through visual collaboration surfaces like grids, kanban boards, and calendars. It provides 8 skills for interacting with Airtable data and supports sync integrations with tools like Jira, Salesforce, Zendesk, Google Drive, and Databricks.

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 is a curated directory of Agent Skills—reusable instruction sets for AI coding assistants like Claude Code, Cursor, GitHub Copilot, and Gemini CLI—including guides for skill creation, platform compatibility, and contribution standards. The repo itself is a standalone skill that teaches developers how to understand, organize, and maintain the awesome-skills resource collection.

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

The Blackpoint Cyber plugin provides Claude Code with read-only access to CompassOne MDR data including detections, assets, vulnerabilities, and tenant hierarchies for MSP incident response investigations. It integrates through the Conduit MCP gateway and requires a CompassOne API token for authentication.

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

The crewhu plugin integrates Crewhu's survey, recognition, and gamification platform into Claude Code, enabling analysis of CSAT/NPS responses, badge management, prize redemption tracking, and user inspection for MSP teams. It exposes 18 tools through the Crewhu MCP server via the WYRE MCP Gateway, including survey detractor/promoter breakouts, badge history, and prize catalog queries.

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

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

This Claude Code plugin integrates Freshdesk cloud helpdesk and PSA ticketing, enabling ticket management (create, search, reply, update), contact and company CRUD, knowledge base navigation, and SLA/business-hours inspection for MSP teams. It provides two commands (/search-tickets, /ticket-summary), one triage agent, and five skills covering ticketing, contacts, knowledge base, and SLA policies.

Inforcer provides read-only governance visibility into Microsoft 365 security baselines across managed tenants, surfacing alignment/drift scores, identity inventory, and audit events through an MCP server integration. This plugin exposes tenant management, baseline comparison, compliance reporting, and the ability to trigger assessment runs, with one command-line interface for portfolio-wide drift reports and single-tenant posture snapshots.

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.

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

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

TimeZest plugin for Claude Code enables MSP technicians to book appointments against ConnectWise, Autotask, and Halo PSA tickets with customer self-service scheduling links and lifecycle tracking. It manages scheduling requests, technician assignment, appointment types, and team round-robin allocation through the TimeZest API.

The Wyre MSP Gateway Plugin provides unified Claude Code access to 30+ connected MSP vendor tools (Autotask, IT Glue, Datto RMM, SentinelOne, etc.) through a single OAuth-authenticated MCP gateway. Tools from each vendor appear under namespaced prefixes and vendor connections are managed through a shared web UI, eliminating the need for individual plugins and separate API keys.

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.

lcm is a shared memory infrastructure for Claude Code agents that replaces sliding-window context loss with DAG-based summarization and SQLite-backed message persistence. It preserves every message, compacts older context into summaries, and promotes durable findings into cross-session memory via MCP retrieval tools.

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.

Astrable is a standalone Agent Skill that delegates bounded coding tasks from GPT-6 Astra to Claude Fable 5.1 through Claude Code, with reviewed handoffs, isolated worktrees, live progress tracking, and persistent verification of changes. Astra scopes the assignment, monitors Claude's work, verifies edits independently, and records decisions—letting two AI models collaborate with clear accountability and resumable sessions.

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

Worktree Task launches autonomous Claude Code or Codex instances in separate git worktrees with automatic error recovery and monitoring. It handles background task execution, progress tracking, cleanup, and merge/rebase operations with macOS notifications.

A catalog of 25 reusable agent skills for orchestrating dev work, decision-making, and documentation without writing code yourself. Skills cover team workflows (orchestration, handoffs), decision-making (grilling, advisory boards), code review, and writing in both agent and human voices.

tap enables multiple AI agents (Claude, Codex, Gemini) to coordinate on the same codebase using a file-based communication layer and shared workspace without custom integration code. It provides CLI commands to orchestrate parallel worktrees, manage bridge connections, and enable agent-to-agent handoffs through a comms directory structure inside the repo.

This plugin provides five core skills for ecosystem navigation, skill creation, research pattern analysis, session reflection, and plugin development, with a UserPromptSubmit hook that forces skill evaluation on user input. It integrates via a shell-based activation script to enable automated skill assessment workflows.

Foreman keeps a project roadmap alongside your code and checks task context before handoffs, supporting Claude Code, Codex, and Antigravity. It tracks task status, blocks, and work awaiting acceptance while letting you verify plans against current code and review lessons from earlier work.

Forge transforms Claude Code into a structured plan-execute-validate loop with parallel work, intelligent retry, and persistent memory across sessions. It breaks multi-file features into isolated modules with dependency tracking, runs independent modules in parallel with worktree isolation, validates deeply with per-module verification commands, and retries failures with debugger context.

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

The ccswap Agent Skill helps a coding agent make quota-aware decisions by reading Claude Code and Codex account quotas, computing headroom, and recommending account switches before rate limits are hit. It integrates with ccswap's list/status/codex JSON output to enable agents to check quota pressure, decide whether to fan out subagents, or pick the best account with remaining capacity.

The autopilot plugin automates the complete engineering workflow from requirements to code merge, with AI-adaptive speed modes, interactive brainstorming, red-team adversarial testing, and QA gating. It includes requirement management via project DAGs, intelligent commits, engineering health diagnostics, and automatic worktree initialization with knowledge base accumulation across tasks.

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

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

cxpak is a Claude Code plugin that provides structured codebase context through auto-invoked skills, on-demand commands, and MCP tools spanning 43 languages via tree-sitter. It analyzes project health, dependency graphs, change impact, and security surface in real-time with deterministic output across LSP, HTTP, and MCP interfaces.

Fleet Deck is a localhost control plane that displays all Claude Code sessions running on your machine on a single web board at http://127.0.0.1:4711, with live status derived from hook telemetry, conflict detection for concurrent file edits, and messaging between sessions. It provides features like permission-prompt handling, live terminal access via xterm.js, session revival from transcripts, and spawning of new agents, all designed as an optional accessory that never blocks Claude Code's terminal operation.

fuse-lessons maintains a committed "never reproduce" lessons file (MEMORY/LESSON.md) at the project root, recording compact one-line failure–fix pairs that are automatically injected into context at every Claude Code session and sub-agent start. The plugin hooks session and task lifecycle events to force-read lessons on startup, remind you to capture lessons on finish, and detect writes to the lesson file to throttle reminders intelligently.

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

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

ACE Context Engineering provides three standalone Agent Skills for managing evolving context in Claude Code: curate-delta synthesizes Reflector insights into structured delta proposals following the Curator architecture, generate-appworld-code generates Python for AppWorld agent tasks using playbook guidance, and reflect-appworld-failure analyzes AppWorld failures to extract API patterns and generate actionable playbook bullets with code examples. The system uses TF-IDF retrieval, JSON schema validation, and deterministic delta merging with feedback integration to incrementally improve context through atomic bullets and tagged guidance.

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

Karma is a Claude Code plugin providing 5 agent skills to find funding opportunities, create and manage projects, administer funding programs, and post milestones and updates—all on-chain via the Karma API with gasless transactions. Skills enable project setup, project management, funding program administration, and discovery of grants, hackathons, bounties, and other opportunities across the Karma ecosystem.

ThumbGate is an MCP-compatible gate system that prevents AI agents from repeating mistakes by converting thumbs-down feedback into permanent pre-action blocking rules. One thumbs-down blocks a pattern forever across sessions and models, eliminating duplicate token spending on the same error.

This plugin provides 50 agent skills and an MCP server for LaunchDarkly feature flag management, including flag creation, targeting, cleanup, guarded rollouts, and metrics. It also includes AgentControl skills for managing LLM configs and experiments with built-in support for A/B testing and prompt management.

Atelier Pipeline orchestrates eleven specialized AI agent personas (Eva, Robert, Sable, Sarah, Colby, Poirot, Agatha, Ellis, Distillator, Sherlock, Sentinel) to manage code quality, design validation, and testing across feature builds with multi-wave QA gates and blind review. It includes an optional persistent memory layer (Atelier Brain) backed by PostgreSQL and vector embeddings that retain architectural decisions, user corrections, and QA lessons across IDE sessions.

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

H·AI·K·U is a Claude Code plugin that orchestrates AI workflows through structured stages with role-based "hats," completion criteria, and adversarial review gates, keeping state on disk to survive context resets. It provides 31 skills across multiple pre-built lifecycle templates (Studios) for engineering, go-to-market, and general-purpose work, with hooks for PreToolUse and PostToolUse events.

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

AI Adoption Playbook is a structured consulting framework delivered as 14 skills that diagnoses adoption blockers, builds phased rollout plans, and generates board-ready narratives with quantified impact across cost efficiency, revenue, capacity, and outcomes. It connects to Asana, Atlassian, Box, HubSpot, Linear, Notion, PostHog, Slack, and Microsoft 365 to pull org context and operational data into AI strategy planning.

breaking-coding-chaos (BCC) is a human-in-the-loop dual-loop control-plane skill suite for coding agents that keeps progress and technical detail under control while implementing concrete ideas. It provides four Agent Skills that work across all agentic coding runtimes (Claude Code, Codex, Grok, Cursor, OpenCode, Hermes, OpenClaw) to maintain durable context, enforce design alignment before code, and produce minimal correct diffs—especially powerful for multi-week work, high-stakes bug fixes, and resume-after-context-loss scenarios.

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

Yggdrasil provides a local-first, persistent memory system for AI coding agents that persists decisions, lessons, and project status across sessions, tools, and projects with zero external dependencies. It injects automatically at session start and allows agents to recall and share context from previous work without re-explanation.

An MCP server for pipeline-driven task management with configurable stages, multi-agent collaboration, dependency tracking, and a real-time Kanban dashboard. Integrates with Claude Code, Codex CLI, Gemini CLI, and Aider through MCP tools, REST API, and WebSocket endpoints.

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

This Claude Code plugin enables management of Linear issues, projects, and teams through a dedicated skill and guards issue-related operations with hooks that normalize input and enforce preconditions. It provides workflows for issue management and Linear API usage, with automatic default state assignment for new issues based on plugin configuration.

This Claude Code plugin gates and validates planning workflows by enforcing plan size limits, detecting unchanged resubmissions and suspicious patches, while injecting guidelines and delegation context throughout the process. The `plan:review` skill compares approved plans against branch diffs to surface implementation drift and follow-ups.

This Claude Code plugin provides code review workflows for pull requests, enabling peer reviews on GitHub/GitLab with comment mapping and batching, plus follow-up tracking and inbox dispatching. It includes skills for drafting review replies, requesting human review via terminal or browser, and running automated audits on isolated worktrees.

ARIA captures session insights, decisions, and feedback into a governed, tag-indexed knowledge base that actively shapes development via change-decision hooks, contextual retrieval, and codebase mapping. The plugin enforces a five-phase lifecycle (capture → govern → promote → apply → refresh) and integrates with 10+ work-management and communication platforms via MCP servers.

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

Scout is an autonomous knowledge management system that monitors work tools (Slack, Calendar, Linear, GitHub, Gmail) and synthesizes findings into a persistent, structured knowledge base while delivering daily action items via scheduled Claude Code sessions. It cross-checks claims across sources, tags findings by confidence level, surfaces contradictions, and self-improves by tracking mistakes and rewriting its own instructions based on feedback.

Scout is an autonomous daily briefing system that monitors work tools (Slack, Calendar, Linear, GitHub, Gmail) and synthesizes findings into a persistent, formally-structured knowledge base with confidence-tagged action items. It runs unattended via scheduled Claude Code sessions and improves itself over time by tracking mistake patterns, rewriting its own instructions, and conducting autonomous research.

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

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

beady-eye wakes Claude Code sessions when watched beads change status, become ready, receive comments, or are removed, enabling reactive workflow automation for pull-request and agent management. It integrates via a PreToolUse hook and MCP server to monitor bead state changes and trigger agent actions.

PMM provides structured, git-backed memory for Claude Code by persisting decisions and lessons in markdown files that auto-load each session, with decision history traceable through git commits. It prevents context rot by preserving decision rationale and alternatives through manual saves and automatic session-start/stop hooks, avoiding the lossy compression of traditional AI memory summaries.

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

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

This Claude Code plugin enables conversational management of Carta CRM data—search, add, update, and enrich investors, companies, contacts, deals, notes, and fundraisings through 26 skills. It includes analytics, meeting prep briefs, and warm introduction routing powered by the Carta CRM MCP Server.

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

Manifestack audits your project's tech stack against budget, users, data compliance, and team constraints, then flags requirement gaps, duplicate services, vendor limits, and bills—with fixes from live vendor pages. It works read-only with no API keys, monitoring every new dependency your coding agent adds through a hook.

mcp-agent-social is an MCP server that enables AI agents to authenticate, post, and interact in team-based social discussions through a remote API. It provides tools for agent login, reading posts with filtering, and creating posts or threaded replies.

NodeBench is an MCP-based operating intelligence plugin that provides 9 core tools for company investigation, competitor analysis, and research workflows, with the ability to discover and load deeper toolsets on demand. It includes slash commands for QA automation and reliability audits, plus auto-QA rules that trigger after code changes.

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

Adjutant is a real-time command post for multi-agent orchestration via MCP, providing a retro terminal dashboard where you can watch agents work, assign missions, and track tasks using persistent messaging channels backed by Beads issue tracking and SQLite. The Claude Code plugin automatically injects an agent protocol (PRIME.md) at session start and context compaction, and offers skills for MCP tools, epic planning, broadcasting, direct messaging, and proposals.

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

Haytham transforms raw startup ideas into implementation-ready specifications through a four-phase pipeline: market research and GO/NO-GO validation, MVP scoping with capability models, build-vs-buy analysis and architecture design, and OpenSpec generation ready for coding agents. It runs entirely within Claude Code using only bash and Python, with no external APIs or keys required.

memory-toolkit preserves session context across compaction and task switches by capturing decisions, corrections, and workstream state into markdown files without external dependencies. It uses hooks to auto-extract session notes every 3 minutes and manages structured handoffs between sessions so you can resume complex work without rebuild.

Sema is a content-addressed vocabulary protocol that ensures shared meaning across AI agents by deriving unique identifiers from cryptographic hashes of pattern definitions, enabling agents to detect semantic divergence and halt rather than fail silently. It provides both an MCP server with tools for searching, resolving, and verifying semantic patterns, and a Claude Code plugin with skills that teach agents when to search, mint, embed handles, and verify meaning at boundaries.

The Astravue MCP Server integrates your Astravue project management workspace with AI tools, enabling natural language management of spaces, projects, tasks, subtasks, checklists, comments, and time tracking through OAuth 2.0 authentication. It provides 8 pre-built skills for workflow automation including sprint planning, status reporting, and bulk task updates across Claude Code, Claude Desktop, Cursor, VS Code, and other AI-powered IDEs.

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

Credo is a self-contained process layer and mentor framework for Claude Code that enforces a project-local workflow with per-session modes (active/passive/autonomous), work-item lifecycle management with a hard Definition of Done gate, budget-aware autonomy, visual UI verification, and safety rules that propagate into subagents. It provides 15 commands, 26 skills, and 19 hooks to manage session state, task progression, API budget limits, and delegated work safety through composable shell-based tooling.

junior-flow helps junior developers create technical story markdown from story trackers or feature descriptions by automating the initial story-flow workflow step. It integrates with the story-flow plugin and the code-review plugin to guide developers through planning, implementation, and code review cycles.

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

Humanize turns terse local workflow requests into checked, reviewed, and runnable MCP flow packages via the humanize-plugin-mcp MCP server. This plugin enables Claude Code to manage multi-step workflows with automatic validation, locking, and review before execution.

Ken enforces a systems-discipline philosophy inspired by Ken Thompson's Unix design approach, guiding AI agents through a structured loop of thinking first, stealing proven ideas, building bottom-up, brute-forcing until measured, and rewriting over patching. It provides 6 skills, lifecycle hooks, and shell-based commands to track code health metrics like rewrites, reuse, root-cause fixes, and dependency vouching.

Nimbalyst Wiki is a local markdown wiki that Claude Code agents automatically populate with session notes, decisions, and tracked items, viewable and editable in your browser without external accounts or servers. The plugin captures decisions at session end, maintains a shared wiki across multiple agents, and stores everything as plain files in your repo.

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

attune-ai adds persistent memory and receipt-verified workflows to Claude Code, featuring 28 auto-triggering skills for code review, testing, security audits, documentation, and spec-driven development without requiring explicit commands. The plugin uses quality gates, pre-run contract previews, and independent probe verification to ensure work is completed reliably, with decision records that persist across sessions.

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

A collection of 11 open-source strategy frameworks delivered as AI-guided markdown skills that run on any LLM (Claude, ChatGPT, Gemini, etc.), covering diagnosis, decision-making, and innovation—from market positioning and competitive advantage to first-principles strategy and pre-mortems. Each skill operates in three modes (Diagnostic, Review, Alert Triggers) and reads/updates a shared company-context.md file to accumulate strategic intelligence across sessions.

feature-discovery orchestrates a multi-agent workflow that fans out across competitor research, seven ideation lenses, and adversarial validation to turn vague product questions into a ranked roadmap of specific, vetted feature candidates. Every proposed idea traces back to a concrete product gap or named competitor capability, with results synthesized into an executive summary and detailed specs.

A standalone agent skill set for GitHub issue lifecycle management that helps LLM teams brainstorm design approaches, create structured issues with machine-parseable templates, triage backlogs, and audit stale issues. It includes five skills—brainstorm, create, triage, audit, and update—each designed with agent-first contracts using special tags like VERIFY: and AGENT-DECIDED: to enable autonomous execution by AI coding agents.

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

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

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

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

CodeLedger tracks token-level costs across Claude Code, Codex CLI, Cline, and Gemini CLI, breaking down spending by project, agent, and skill while separating user coding work from plugin overhead. It provides conversational MCP tools for querying usage, a local dashboard, budget alerts, and cost optimization recommendations based on evidence-based rules.

An MCP server that connects AI assistants to Frihet for business management, enabling natural language operations for invoice creation, expense tracking, client management, and Spanish/EU tax compliance with 158 canonical operations. The plugin supports demo mode for zero-setup testing and integrates with multiple AI platforms including Claude, ChatGPT, Cursor, and Gemini CLI.

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

Project Scaffolder generates a complete project structure from a brief, including a persistent 12-page wiki, domain-specific skills, execution docs with model routing, and a gated task pipeline with QA and user testing to maintain code consistency across sessions. The plugin uses 19 slash commands, hooks to prevent destructive operations, and a skill lifecycle system that grows expertise over time.

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

SOSA Governor implements real-time governance for Claude Code by classifying MCP tool calls by impact level, blocking high-impact actions (like sending messages or deleting data) until user approval, and maintaining audit logs and trust scores. The plugin uses hooks to intercept tool calls at session start and pre/post execution, plus an on-demand skill for audits, compliance checks, and trust management.

statusline-kit displays live telemetry for Claude Code sessions, showing active commands, skill runs, per-subagent context usage and costs, and generating per-run reports with totals and agent summaries. It uses shell hooks to track session events and requires jq for JSON processing.

The Accelerate AI Toolkit integrates Claude Code with WordPress Accelerate to diagnose site performance issues, recommend A/B tests, and track outcomes through natural conversation. It runs 16 purpose-built skills—from real-time performance review to personalization and attribution analysis—all grounded in your site's actual traffic data.

Agent-comm is a Node.js system that enables AI coding agents to communicate, share state, and coordinate edits through MCP, REST, and WebSocket transports, with hooks that serialize file access and prevent conflicts. It provides agent discovery, messaging (direct/broadcast/channel), a shared key-value store, activity feeds, and a real-time dashboard for multi-agent workflows.

Artel is a self-hosted coordination layer that provides shared semantic memory, tasks, async messaging, and session handoffs for AI agent fleets—the Claude Code plugin makes this memory "ambient" by automatically injecting relevant knowledge and skills at the right moment and capturing sessions back into the store. The plugin wires up MCP server integration and session hooks so every Claude Code session inherits prior context, reads its inbox, sees file-anchored notes before edits, and seamlessly persists what happens without requiring explicit agent discipline.

BudgetClaw adds Claude Code cost tracking per project and branch with a `/spend` slash command and session-start hook that displays current spending, budget limits, and breach locks. It reads local ~/.claude session logs and syncs to a hosted team dashboard via the BudgetClaw CLI tool, enforcing budget caps with SIGTERM when limits are exceeded.

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

Search, score, and rank GitHub developers by profile metrics and job description relevance using an MCP server that exposes 9 tools for technical recruiting workflows. Integrates with Claude and GitHub Copilot to automate candidate sourcing, profile analysis, and comparative scoring across repositories.

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

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

Second Brain is an agentic workflow plugin that captures Claude Code sessions with rich metadata, distills them into organized knowledge, and retrieves relevant context for future sessions. It transforms Claude from session-to-session amnesia into persistent tribal knowledge by automatically organizing artifacts, generating session recaps, and surfacing past work when needed.

skraft turns refined user stories into researched, designed, tested, and reviewed code changes through a deterministic four-phase engineering pipeline (RESEARCH→DESIGN→DISTILL→DELIVER) with specialized agents and adversarial reviewers for each phase. Runtime hooks enforce phase order, artifacts, verdicts, and commits while supporting outside-in TDD, Clean Architecture, BDD, and safe brownfield modernization workflows.

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

claudestory enables cross-session context persistence for AI coding projects by maintaining a `.story/` directory that tracks tickets, issues, roadmap, handovers, and notes across Claude Code sessions. The plugin provides 30 MCP tools, CLI commands, and autonomous work execution features so each session builds on the previous one without re-explanation.

This Claude Code plugin manages tasks in a filesystem with three states (open, wip, done) and integrates with git for tracking changes. It provides commands and lifecycle management through hooks that trigger on session start and tool use.

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

zd-usage monitors Claude Code token consumption and costs locally by reading transcript files, providing per-session ledgers and daily/weekly/monthly reports by project and model without external data transmission. It enforces weekly token budgets with session-start warnings at 80% and 100% thresholds, supports team CSV export and merging, and runs standalone via Node.js scripts.

accounts-pack binds Claude Code projects to specific accounts (alternative ~/.claude config directories) and ensures every session runs under the bound account, with SessionStart warnings if the wrong account is detected. It integrates with the swarmery CLI to manage account selection via shell wrappers, optional shell functions, and project-level bindings stored in .claude/settings.local.json.

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

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

This Claude Code plugin enforces design-first coding by rendering plans and code reviews as annotated call graphs (Design Graphs) in a stack-agnostic notation before implementation begins. It provides commands to toggle Design Thinking mode, generate and review call graphs, and map the graph protocol onto language-specific idioms like error handling and resource management.

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

Game of Cards is a standalone agent skill that implements a Kanban-based task management system for AI-human collaboration, where work items are markdown files with frontmatter, checklists, and decision gates. It provides 15 skills (create-card, advance-card, audit-deck, finish-card, and others) that translate natural language requests into structured card operations, with no external service dependencies.

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

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

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

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

oculpm is a Claude Code plugin that integrates with ocul-pm to provide local-first work journaling, project planning, and session tracking through hook bridges and MCP tools that append markdown journals and plans to a project's .oculpm/ directory. It includes skills for journaling, project inception, self-audit, evals, and TDD, and works only in repositories already tracked by ocul-pm on macOS, Linux, and Windows (via Git Bash).

This Claude Code plugin bootstraps jj (Jujutsu) workflow enforcement for any project with a /project-setup command, installing hooks that display jj state at session start and block raw git commands via PreToolUse guards. The plugin actively prevents git access and validates jj flags as soon as it's enabled, using bash scripts to enforce jj-first VCS practices.

Helps a founder think through feedback from a Board of Advisors meeting or mentor session, organize insights with a confirmation gate, and build a follow-up outline to action items. The skill structures the founder's own notes and recall into confirmed talking points without fabricating evidence or writing the email itself.

Helps a StartX founder prepare for Board of Advisors meetings by running six forcing questions across the company and assembling an advisor-ready pre-read with evidence and explicit risks. Sharpens founder thinking and surfaces gaps without making decisions, inventing evidence, or writing code.

A standalone Agent Skill that guides StartX founders through six forcing questions to sharpen their ask for mentor sessions, routing by session type and BoA cycle phase to build a prep document in StartX's challenge format. It helps clarify thinking without inventing evidence or making decisions for the founder.

Superpowers is a software development methodology plugin that equips Claude Code with 14 composable skills for test-driven development, debugging, and collaborative agent workflows. It automates a structured process from spec gathering through subagent-driven implementation with autonomous task execution and review cycles.

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

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

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

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

This plugin provides 36 atomic capabilities organized across 9 cognitive layers for building reliable AI agents with typed contracts, safety checkpoints, and grounded reasoning. It enforces structural reliability through pre- and post-tool-use hooks that manage checkpoints, audit logging, and provenance tracking to prevent hallucinations and enable rollback on failures.

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

This plugin is deprecated; Claude Code v2.1.277+ natively reads AGENTS.md files through the built-in agents-md mod. It previously enabled automatic loading of AGENTS.md project instructions at session start and after file reads, with hierarchical directory support for monorepos.

claude-flow is an open-source framework that equips Claude Code with structured project knowledge and autonomous execution capabilities through 4-layer project configuration (Constitution → Rules → Skills → Commands) and an 8-layer autonomous engine. This standalone Agent Skill provides 4 built-in skills (tdd, verification, brainstorming, and one unnamed skill) for test-driven development, pre-completion verification, and design exploration workflows.

Claude Launchpad scores and auto-fixes Claude Code configurations across instruction budgets, CLAUDE.md quality, settings, hooks, rules, permissions, and MCP servers. It provides local analysis (no API calls), optional stack detection during init, and includes two agent skills (lp-enhance and lp-migrate-memory) to enhance and manage configuration over time.

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

The Concordia Protocol plugin provides 59 MCP tools enabling autonomous agents to engage in structured negotiation with binding commitments, multi-attribute offers, session receipts, reputation tracking, and agent discovery. It requires the concordia-mcp-server and Python 3.10+ to operate as a negotiation framework for both Concordia-compliant and non-Concordia peers.

consolidate-memory provides cross-project, verification-first memory for Claude Code by sharing fact-checked memory across enrolled projects in the same trust domain and verifying facts against live code via grep, file, and git operations. It complements Auto Dream with explicit, rigorous memory consolidation invoked via commands like "consolidate," "checkpoint," or "dream," while maintaining tiered context-budget accounting and dropping unconfirmed facts.

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

Discovers and aggregates Agent Skills from local directories, Git repositories, and plugin marketplaces into a unified catalog accessible via DeepSeek Harness or a local stdio MCP server. Includes CLI tools for validating skill resources, checking for missing references, and inspecting instructions before loading them into agent tools.

A 22-skill Claude Code plugin that generates production-ready engineering documentation across the complete software lifecycle, from business concept through deployment and operations. It conducts structured interviews to gather context and auto-generates cross-consistent documents in ISO/IEC/IEEE 29148, C4 Model, STRIDE, and Google SRE formats.

Jevflow keeps Claude accountable on long coding tasks by breaking work into phases with explicit definitions of done, then uses the Jev model to audit each stop and decide whether to advance, block with concrete next steps, or allow completion. Multiple agents can share one plan, all flows are persisted and viewable in a live web UI, and crashes resume from exactly where they stopped.

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

This plugin connects Claude Code to the Forge orchestrator's MCP server, enabling access to tasks, knowledge, and drift management features bound to your project root. It integrates via a UserPromptSubmit hook and works as a companion to the nxtg-forge tool, automatically installed when Forge is set up.

Nyann is a Claude Code plugin that bootstraps and maintains project governance by detecting your stack and automatically installing git workflows, hooks, branching conventions, CI templates, and documentation scaffolding. It handles tasks like Conventional Commits, branch creation, releases, PRs, and hygiene audits conversationally or via slash commands.

TMB is a multi-agent orchestration harness for Claude Code that splits work across specialized roles—bro (planner), swe (executor), and pr-reviewer (independent validator)—backed by a persistent SQLite trajectory log and kuzu world model that preserves state across context resets. It gates code changes at task completion and push time, enforces role separation to prevent self-approval, and maintains an auditable record of decisions and verdicts for long-horizon multi-task work.

This Claude Code plugin records manual tasks that only the user can complete (like approvals or account changes) in a local SQLite database and displays them on a visual task board organized by project. Tasks can span multiple repositories, include exact values and links, and are tracked through a browser-based board, status line integration, or terminal CLI commands.

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

This Claude Code plugin orchestrates multi-step agent workflows using YAML-defined finite-state machines, handling state transitions, nested sub-workflows, and shell command execution with real-time dashboard visualization. It includes 19 bundled workflow templates and 20 reusable skills, auto-provisioning resources via SessionStart hooks.

This MCP server and Claude Code plugin orchestrates multi-agent AI workflows through structured markdown documents with automatic context injection and pre-built workflow templates for development, testing, planning, and decision-making tasks. It provides 13 commands and 2 agents to manage specifications, coordinate task assignments, and maintain impartial code reviews across sequential or ad-hoc project work.

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

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

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

The briefing plugin uses a PreToolUse hook to pre-load skills declared in agent frontmatter before a subagent spawns, eliminating the need for prompt-stuffing workarounds. Skills are resolved from project, user, and plugin caches and injected directly into the agent's context, with hard failure if any declared skill cannot be found.

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

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

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

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

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

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

A German legal assistant for SMBs covering 12 practice areas of federal and state law with 16+ interactive calculators for employment, tax, data protection, and contract review. The plugin integrates with Google Calendar, Gmail, Microsoft 365, Slack, Box, Atlassian, and Egnyte to help teams manage legal workflows and compliance.

A Claude Code plugin that organizes scattered AI usage into a reusable, team-owned design practice through a five-layer harness: Context, Skills, Orchestration, Rubrics, and Knowledge. Four skills enable learning, setting up, maintaining, and reviewing the harness across Notion, Figma, and version-controlled repo artifacts.

Kauri integrates a deterministic decision database into Claude Code, auto-injecting project decisions at session start and exposing 12 MCP tools for recording, querying, and validating decisions alongside standard editing commands. Post-commit hooks detect stale decisions and alert the agent, while guided skills teach Claude when and how to use Kauri's structured lifecycle semantics.

This plugin provides civil, commercial, and family litigation management for Spanish law firms, handling case portfolios and generating legal documents including complaints, responses, appeals, and enforcement proceedings in compliance with LO 1/2025 and current civil procedure law. It integrates with Jurisprudenciator for Spanish jurisprudence search across national and regional courts, and with Dropbox for document management.

Madrox is an MCP server that orchestrates multiple Claude, Codex, and Grok agent instances as parallel workers, enabling recursive multi-level team hierarchies with bidirectional communication and real-time monitoring through tmux sessions and a web dashboard. It provides 24+ MCP tools for spawning teams, managing resource limits, interrupting tasks, and tracking metrics across hierarchical agent networks.

This plugin automatically opens a GitHub issue from each Claude session's first prompt and posts a comment at each exit summarizing activity (prompts, tool use, publications), with optional activation via environment variable or /session-issue command. It integrates with miadi-session-observability's capture data when available, sanitizes secrets from all posted text, and only targets private/internal repositories.

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

PhanesLight is a multi-agent orchestration system for Claude Code that generates a project-specific agent roster, enforces code discipline through pre/post-tool hooks, and maintains durable project memory across sessions using a single bootstrap prompt file. The plugin ships language-independent scripts and templates that integrate into any repository without external dependencies beyond Node.

A Claude Code plugin for writing product requirements documents, drafting and filing engineering tasks, and maintaining work logs—all configured to read from and write to your choice of markdown files, git repos, Notion, or custom trackers. It keeps product specs and task tickets synchronized, extracting work context from chat threads and generating accomplishment statements from daily logs.

PM AI Partner provides 13 specialized agent skills and 7 workflow commands that turn Claude into a product manager's thinking partner for strategy, writing, analysis, and decision-making. It includes 4 automation hooks and optional connections to 17 MCP servers (GitHub, Linear, Jira, Slack, BigQuery, and others) to integrate with PM tools and data sources.

signal-monitor analyzes competitor changes, search/traffic shifts, and named signals to surface up to five prioritized product opportunities, each linked to a brain field and Section 7 priority with evidence and next steps. It saves dated analysis to your context without editing your brain or scanning unprompted.

Roadmap plugin organizes development work as a JSON-based dependency graph with automatic status computation, Mermaid diagrams, and an HTML dashboard. It provides skills for suggesting next tasks, managing assignments, maintaining status consistency, and conducting roadmap reviews to keep teams aligned on priorities and progress.

A Claude Code plugin that captures session learnings to native memory by monitoring work activity through hooks and offering batch retrospectives at end of day. It uses deterministic event logging to ask targeted questions about actual code changes and decisions, avoiding interruption until enough sessions accumulate.

This plugin enforces team engineering standards by automatically loading CLAUDE.md guidelines at session start and provides skills to verify dependencies and automate PR workflows (commit, push, create PR, and CI checks). It requires the gh CLI and integrates with your team's Git and CI processes.

Tribeunal is a decision-making platform where AI agents can open cases, seat hybrid juries of humans and AI, weigh evidence, and await verdicts before taking action, accessed via a hosted MCP server with Auth0 sign-in. The plugin ships eight Agent Skills that implement complete decision workflows—from framing a case and waiting asynchronously for verdicts to running binding arbitrations and delivering signed webhooks—enabling agents to participate in structured group decision-making processes.

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

Wakeflow orchestrates multi-window Claude Code sessions across tmux to manage structured work packages from requirements through testing and archival, maintaining explicit on-disk state and audit trails at each step. The Controller window claims and plans work while specialized windows (Design, Target, Test) execute tasks within a disciplined control loop that tracks evidence and gates acceptance on independent validation.

Attacca is a multi-agent orchestration layer that translates product requirements into working, tested, and audited code across eight AI coding tools (GitHub Copilot, Cursor, Cline, Windsurf, Claude Code, Codex CLI, Gemini CLI, Google Antigravity). It provides eight declarative skills spanning code review, test-driven development, security audits, supply-chain defense, SBOM generation, quality gates, incident response, and workspace mapping—all with shared state files and adaptive workflows based on tool availability and budget.

claude-wayfinder replaces prose-based agent and skill routing with a deterministic, auditable scoring kernel that makes typed dispatch decisions based on structured task context rather than raw prompts. It builds a typed decision contract with seven possible outcomes (delegate, self_handle, self_handle_unaided, advisory, ask_user, needs_more_detail, mixed_content) and generates its routing catalog automatically from skill sidecars and agent frontmatter at session start.

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

EF Harness is a Claude Code plugin that enforces a five-stage feature pipeline: grilling decisions, authoring RFC/PRD docs, discovering per-repository constraints, building against named test proofs, and conducting an adversarial audit gate. The plugin includes a deterministic `/ef:ready` checker that validates the agent rulebook against the actual repository to catch stale rules and prevent self-verification.

fakoli-flow orchestrates specialist agents through a five-stage intent-driven pipeline (brainstorm, plan, execute, verify, finish) that enforces quality gates between waves and generates acceptance-criteria-focused plans rather than prescriptive code. It uses hook-enforced critic gates and evidence-based verification to coordinate complex projects without prescribing implementation details.

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

hippo is a perception and memory plugin that maintains a task registry, append-only outcome ledger, and background clerks to turn session transcripts into evidence for coding agents. It records observations and context without enforcing policy, leaving judgment with the model, and exposes its functionality through CLI commands, slash commands, and hooks.

Kraken is a decentralized task queue for AI coding agents built on GitHub Issues, where named workers (Claude Code, GitHub Copilot CLI, or protocol-conforming tools) claim tasks, execute them, and record results as draft PRs—with no server or daemon to operate. It implements kraken-protocol/9 using GitHub's native issue labels and git refs for coordination, dead-worker recovery via expiring leases, and dependency tracking.

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

This plugin manages Miadi Chronicle episodes through the mkepisode kit, which creates, adopts, registers, and closes episodes while enforcing their lifecycle via a PreToolUse hook that blocks manual directory creation. It provides three MCP servers (inquiry-weave, miadi-voice, medicine-wheel-miadi-chronicle) for episode operations, voice management, and medicine wheel integration.

This Claude Code plugin automatically captures session events for Miadi hosts by hooking into Claude Code lifecycle events and writing structured logs, maintaining compatibility with existing token counters and session observers. It records session metadata (bindings, tmux panes, command lines, team assignments) and includes a session-continuity skill for agent recovery after crashes.

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

Delegates coding tasks (implementation and tests) to a local pi agent while Claude writes the task specification and validates results, with enforced discipline modes to prevent Claude from editing production code directly. Integrates via MCP tools (pi_dispatch, pi_status, pi_steer, pi_abort, pi_result, pi_transcript, pi_stats) and hooks that intercept Write/Edit operations in strict or soft modes.

saas-builder is a 22-skill orchestrated agent plugin that guides developers through the complete SaaS lifecycle—from product discovery and architecture through backend, security, payments, and deploy—using a router that asks clarifying questions before activating the right specialist for each phase. It produces production-grade output with field notes from real production failures, works across CLI agents (Claude Code, OpenCode, Gemini, Codex, Copilot), and pairs with Superpowers as its only external dependency.

This Claude Code plugin wraps AI assistance in decision gates and spaced-review coaching to keep humans engaged in high-stakes work: it surfaces decision cards before irreversible actions, poses predict-first questions during debugging or design, and schedules periodic skill reviews based on past sessions. All coaching rules, lessons, and decision logs are stored locally with no external services or API keys required.

skills-ontology manages skill registries, relationship graphs, and usage tracking for Claude Code by transforming flat skill directories into a structured knowledge graph with automatic routing, chaining, and session-based invocation tracking. It provides commands to build, visualize, and analyze skill ontologies, plus hooks that detect drift and track usage patterns in real time.

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

straw-boss routes work through Claude Code, Codex CLI, or Antigravity workers—keeping bounded tasks in the current session, fanning out clear branches, or spawning durable app-rooted workrooms with shared git lifecycle tracking and event-driven coordination. It uses provider-neutral dispatch through Herdr with cross-app routing support for monorepos, all orchestrated by the `boss-say` skill.

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

A local dashboard that displays real-time status, token usage, plan limits, and inter-session messaging for all active Claude Code sessions running on your Mac. It monitors session activity, calculates API-equivalent costs, shows usage patterns over time, and enables direct communication between sessions through a visual interface.

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

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

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

This plugin generates access review reports using an MCP server and a custom skill. It requires npx for local execution and offers tiered pricing with free and paid plans.

A library of 171 pre-built AI agent skills covering engineering, design, marketing, sales, product, and specialized domains—automatically injected into Codex CLI and Claude Code workflows without explicit invocation. Combines 149 specialist agents, 21 design commands, and a live-spec enforcement agent to turn any development session into a full AI agency.

agenticos injects contextual brain state into every prompt and automatically captures Claude Code sessions into persistent memory through hooks and an MCP server. It enables telemetry streaming and exposes a vault for managing agent context across sessions.

Agent Runway injects architectural context into subagents before code execution and validates file writes against module boundaries and project conventions. When violations are detected, the agent self-corrects automatically without human intervention.

A Claude Code plugin that provides skills, subagents, and hooks for test-first development workflows with automated routing between model tiers based on task complexity and failure recovery. It includes session handoff tracking, code review integration, and test-proof verification to ensure changes don't introduce regressions.

alps-writer guides you through authoring ALPS (Application Layer Profile Specification) product requirement documents section-by-section via an MCP server in Claude Code. It integrates with the adr-writer plugin to hand off features as architecture decision records using the /feature-to-adr command.

Artibot is a cognitive orchestration framework for Claude Code that integrates 29 specialist agents, 113 domain skills, and an 11-stage runtime middleware pipeline to enable hierarchical memory, verifiable-reward learning (RLVR), and multi-agent team coordination. It features dual-process routing (System 1/2), lifelong learning without external RL optimizers, and built-in MCP server exposure while maintaining data sovereignty on-disk.

The bookclub plugin generates Slack communications, discussion materials, and reading schedules for managing book club activities. It provides 4 commands and 1 agent to automate book club coordination tasks through Claude Code.

can-i-help matches developer skills to open-source project contribution opportunities by analyzing project health signals (test gaps, documentation drift, bugspots, open issues) and asking about contributor background. It provides data-backed, personalized recommendations with concrete next steps for where contributors can make impact.

This Claude Code skill provides full Jira integration for fetching tickets, searching with JQL, managing issues, and generating team digest reports. It supports ticket lookup, creation, updates, status transitions, linking, comments, image attachment analysis, and multi-instance auto-switching with local credential storage.

This plugin provides an agentic loop foundation with deterministic safeguards including append-only logging, confidence thresholds (0.7/0.85), mandatory critic review, and a governance gate that flags but does not block undisciplined code edits. It includes two agents (echo and critic), a /start-project skill for PRD ingestion with drift detection, and hook-based control over tool usage and task execution.

A complete Domain-Driven Design workflow plugin with five composable skills: project initialization, roadmap generation, TDD-driven development, 8-dimension architecture audit, and automated batch execution. Skills orchestrate through a pipeline for analyzing projects, generating phased plans, implementing features with quality gates, and continuously auditing against DDD standards.

This plugin orchestrates implementation delivery by distributing tasks to developer agents, where each task is reviewed and committed before running plan verification and code review. It uses hooks and subagent-driven execution to manage the full workflow from plan approval through final validation.

A comprehensive Claude Code plugin providing 48 engineering skills organized across the full software development lifecycle (product, research, design, develop, tune, test, verify, ship, operate), with shared engineering principles automatically injected at session start. Skills are triggered by task description matching or explicit slash commands, and doc-producing skills generate both project-level and version-level outputs.

forge-skills is an agentic engineering toolkit providing 42 TDD-tested skills, 13 specialist agent personas, and 36 slash commands organized across a seven-stage pipeline (GRILL → SPEC → DESIGN → PLAN → BUILD → REVIEW → SHIP) for structured AI-assisted software delivery. It enforces human-driven specifications and architecture with parallel agent implementation, contract-driven development, and quality gates that cascade upstream edits through generated snapshots with zero downstream writes.

A standalone Agent Skill with 12 slash commands that encode Brian Chesky's founder-mode operating system — including founder-audit, org-health, hiring-scorecard, delegation-scorer, and crisis-catalyst. Each command provides structured analysis, scoring, and actionable next steps grounded in Chesky's practices and Paul Graham's framework.

Fusion is a multi-model orchestration plugin that manages tier agents, routing rules, and model configuration through a blind panel and ultra fleet system. It uses hooks and skills to coordinate model workflows, monitor drift, and handle pre/post-tool execution events across agent sessions.

GAIA is a security-first multi-agent orchestration plugin for Claude Code that deploys specialized agents for different domains (development, infrastructure, planning, etc.), each generating contractual records of their work that persist in a local database across sessions. Every command is risk-classified before execution—reads proceed freely, state changes require approval, and irreversible operations are blocked entirely.

gener8v is a structured pipeline plugin that guides code from raw idea through PRD, specification, design, implementation, and multi-phase reviews—with persistent state, @spec traceability annotations, and support for both greenfield and brownfield projects. It comprises 4 agents and 20 skills that orchestrate requirements, tickets, delivery, audits, and architectural assessments using shell hooks to maintain pipeline state across sessions.

GreyMatter is a Claude Code plugin that creates a persistent, local knowledge base by automatically distilling session conversations into markdown notes, filing them, and retrieving relevant notes when requested. It uses five agents to manage memory lifecycle (distillation, filing, linking, archival, and maintenance) without requiring external APIs or accounts.

Grok is a local Grok CLI delegation plugin for Claude Code that handles tasks, code reviews, resumable history, background jobs, and stats. It provides setup health checks and runs shell commands via Node.js, with hooks for session and stop events.

The growth-roles plugin provides three AI agents—marketing-agent, sales-agent, and data-research-agent—for business growth tasks with deterministic source verification to prevent unsourced claims and an outbound-send gate requiring human approval for external communications. It uses PreToolUse and SubagentStop hooks to enforce guardrails on agent behavior and requires Node.js to run.

Harness Engineering Plugin packages 19 AI-orchestrated skills covering planning, TDD, debugging, code review, and verification into Claude Code — install and activate a complete engineering workflow structure with hooks, progress tracking, and cross-session memory. The plugin auto-triggers skills based on intent and enforces a structured RED→GREEN→REFACTOR loop, with on-demand audits, canary deployments, and subagent-driven parallel task execution.

harnist provides Tuist-style harness modules for organizing per-project skills, plugins, and MCP servers in Claude Code, with an audit trail based on real usage. Commands are user-invoked only, with zero always-on context overhead.

Hats is a BDD-driven AI development team plugin that orchestrates five specialized roles (Manager, Designer, CTO, QA, Developer) in a sequential workflow, using Gherkin specs and role-based file permissions to guide implementation from planning through testing and code delivery. The plugin enforces role isolation through hooks and bash-audit guards, manages task workflows with state gates, and maintains a shared knowledge base across team handoffs.

kgai is a shared decision memory plugin that automatically records structural decisions (what changed, why, rejected approaches) during AI coding sessions and recalls them before making changes, while syncing decisions across teams via immutable, content-addressed events. It stores decisions locally by default with optional team sync via self-hosted S3 or git, supporting 1M+ decisions with ~100ms lookup latency across multiple AI dev environments.

LLM Orchestrator is a Claude Code plugin that structures multi-step development work through enforced planning, task-by-task building, independent code review, and test verification with an optional per-project review cadence. It provides 15 commands, 5 agents, and 18 skills that integrate with Claude Code's existing plan mode, code review, and worktree features while adding governance rules around when each step is required and what counts as proof of completion.

mister-anderson is a Claude Code plugin that implements a structured 3-stage development pipeline (Product Discovery → Specification → Implementation) with task tracking via beads, research validation gates, and mandatory code review and QA checkpoints before merge. All stages maintain full traceability through decision logs and require explicit human approval at each gate to proceed.

Munin is a long-term memory system for Claude Code that automatically saves project context, decisions, bugs, and solutions using GraphRAG, so developers can retrieve relevant past work and solutions without repeating themselves. It includes automatic session summarization, error catalog lookup, semantic search, and a `@munin` agent for direct memory queries, activated via hooks that monitor sessions and tool usage.

Overture is a Claude Code plugin that enables agents to answer questions from an owner via a web-based console protected by Cloudflare Access, providing onboarding, answer processing, and deliberation round management. The plugin includes 8 agents and 15 skills to orchestrate multi-agent workflows and collect owner feedback.

Pathmode runs deterministic preflights on feature requests before an agent builds, checking six calibrated gates without model calls or API keys, and optionally syncs intent specs with a team workspace. The plugin provides `/preflight` commands, intent compilation, code verification against agreed constraints, and product choice tracking—all using models you already have access to in Claude Code.

The Plane plugin connects Claude Code to Plane Cloud's project management tools via MCP, enabling natural-language creation of work items, cycle tracking, intake triage, and standup generation. Authentication uses OAuth to Plane Cloud, and no additional tools or scripts are required—just the MCP server integration.

qa-cube is a QA test-session engine that orchestrates manual and automated testing end-to-end, with a manager and subagents reading tracker tasks, planning test rounds, filing findings, and writing autotests in your project's declared language. It stores sessions, generates business-language reports for tracker integration, and conducts retrospectives that improve its own instructions.

This Claude Code plugin integrates a coding session into a Quorus room, enabling shared group chat with multiple coding agents (Codex, Gemini CLI, opencode, and other Claude sessions) and their human operators. It provides file locks, shared state management, and approval workflows across the collaborative coding environment.

Release Conductor automates the diff-to-ship workflow: it drafts Conventional Commits and PR descriptions, detects behavioral breaking changes to recommend semver bumps, assembles changelogs from any git history, and guides merge-conflict resolution and rebase planning. The plugin bundles five commands, three agents, and two reusable skills to turn fragmented release chores into a guided, evidence-based process.

rpm is an operational layer that gives coding agents durable project state, session lifecycle hooks, and drift detection across LLM-assisted development sessions. It stores project memory in plain-text files under `docs/rpm/` including context, status, backlog, logs, and audit trails—enabling reviewable handoffs and keeping teams on task.

Shipfloor is a Claude Code plugin that turns GitHub issues into shipped pull requests by running multi-agent workflows (spec refinement, development, validation) with human approval gates at each stage. It runs entirely on your machine with deterministic validation scripts that agents cannot edit, ensuring quality control and cost transparency.

A Claude Code plugin that enforces the Shape Up SDLC methodology through a gated runtime pipeline—idea, pitch, build, evaluate, ship—where structural rules block invalid work orders and progress is verified by fixtures and artifacts rather than agent assertion. Includes scope-mapping, T0-verified builds, sandbox guards via PreToolUse/PostToolUse hooks, and optional lightweight gates for one-file fixes.

SoloFounder dynamically assembles specialized AI teams and optimized workflows for any business challenge, generating fresh flows tailored to software, marketing, design, and operations without templates or hardcoded pipelines. It guides users through clarification phases, designs multi-stage execution flows, and creates deeply specialized roles that review each other's work and learn from completed projects.

A nine-skill pack for designing AI-native products and businesses from vision through PRD, conversational UI, and tool stack selection using frameworks like JTBD, RICE prioritization, and closed-loop process design. The skills flow from opportunity scanning and customer need identification through solution ideation, MVP synthesis, feature discipline, and buildable documentation.

A 19-skill consulting expertise pack for Business Model Canvas work, covering facilitation, diagnostic reading, resilience/risk analysis, and AI-native discovery techniques. It targets early-stage and growth-stage companies with tools for canvas clarity, innovation pattern matching, economic prototyping, and organizational-resistance mapping.

A seven-skill pack for scoping and advancing AI initiatives within public-sector and non-profit contexts, covering opportunity screening, stakeholder mapping, procurement navigation, equity assessment, and decision-readiness framing tailored to elected bodies and public-value outcomes rather than private ROI. The skills work together to guide AI proposals from initial concept through formal approval by public decision-makers, accounting for regulatory constraints, disparate-impact risks, and the distinct governance dynamics of public agencies.

This standalone skill pack guides researchers and teams through the entire commercialisation journey—from assessing market opportunity and IP ownership through TTO engagement, funding strategy, team building, and founder readiness assessment. The 12 skills are anchored in a published methodology synthesizing EntreComp and ResearchComp frameworks, covering pathways from research to spin-out, licensing, or hybrid ventures.

The stereo plugin pairs Claude with the Codex CLI to enable mixed-model planning, adversarial code reviews, delegated task execution, and background job management. It provides 15 commands, 4 skills, and 1 agent to streamline multi-stage development workflows through automated session hooks.

Strata is a four-layer long-term memory system for Claude Code that persists raw sessions, extracted facts, project-specific topics, and user profiles in local SQLite with full-text search. At session start it injects relevant memory; at session end it captures new conversations and uses a background Haiku call to consolidate notes, scenes, and profile entries without requiring extra API keys or external services.

subagent-mcp is an MCP stdio server that orchestrates local Claude and Codex CLI sub-agents for long-horizon coding tasks, routing work through authenticated CLIs with provider-agnostic concurrency controls and permission gating. It hooks into Claude Code and Codex sessions to delegate tasks to fresh sub-agents while maintaining state summaries and coordinating across multiple providers via environment-based credential management.

sub-human enables real-time collaboration between separate Claude Code sessions on one machine or over a network link, with shared rooms where Claudes communicate natively and members edit versioned plans together. The plugin uses hooks to post messages without paraphrasing, an MCP server for the shared room state, and native Claude Code messaging between agents, with explicit consent workflows for plan sign-offs.

super-bootstrap orchestrates development pipeline setup and maintenance, installing a generic runway (docs, rules, hooks, default harness) and seizing repo-specific skill/MCP curation. It bundles 13 skills covering commit workflows, backlog triage, docs consistency, and parallel work-item draining—all gated on substantive seed docs and monorepo-aware per-package scaffolding.

This Claude Code plugin provides Taskwarrior integration through AI agent workflows for adding, updating, and closing tasks, with hooks that trigger on session start and stop events. It requires bash and follows Taskwarrior best practices to manage task operations directly from Claude.

usage-guard injects fresh 5h/weekly quota information into Claude's context on every prompt and warns when approaching plan limits with an even-pace readout to help pace work sustainably. It runs entirely locally with zero dependencies, optionally notifies via ntfy on quota resets, and provides a /usage-guard:usage command to check quota anytime.

The usage-tracker Claude Code plugin monitors Claude 5-hour and weekly plan limits per device, displaying per-device usage, caps, and model/effort breakdowns via a web dashboard and /usage-tracker:status command. It intercepts session start, stop, and prompt submission events to track consumption across Claude and compatible agents like Gemini CLI, Codex, and OpenCode.

This Claude Code plugin operationalizes Feature-First Clean Architecture (FFCA) conventions for Flutter monorepos through skills, validation hooks, and an MCP server that enforces layer dependency rules. It provides guidance on feature scaffolding, routing, cross-feature wiring, and includes an auditor agent for architectural compliance.

wyx is a Claude Code plugin that enforces architecture guardrails by automatically injecting module boundary specifications into Claude's context before and after edits, preventing cross-module access violations. It includes drift detection to catch divergence between declared specs and actual code, helping teams maintain architectural boundaries as they scale.

This Claude Code plugin enforces an adversarial review gate on every phase commit: a separate reviewer process examines each git diff before the commit is allowed to proceed, blocking commits with findings until they are resolved. The plugin registers hooks across the session lifecycle to intercept tool use and implement a multi-phase workflow where phases are frozen after proposal and all mutations must pass external review.

agent-orchestration is a task queue system for Claude Code that orchestrates AI agent workflows through markdown task files with YAML front-matter, supporting verification hooks, task chaining, parallel workers, and QA/bug-fix loops. It provides commands to manage task state, run planners to split requirements into tasks, and coordinate multiple agents through hooks (PreToolUse, Stop, SubagentStop) with git-based persistence and optional conductor-based automation.

agichan turns Claude Code and other agent CLI sessions into a distributed swarm that coordinates work through an end-to-end encrypted channel, with workers claiming tasks from a shared board and pushing git branches for each completed task. The plugin uses MCP servers and shell hooks to detect new sessions and task submissions, enabling real-time task distribution and optional payment from escrow without polling loops.

Atelier is a universal multi-agent project harness for Claude Code that orchestrates 8 default agents with governance controls across web, data, ML, fintech, and CLI projects. It enforces structured workflows through 12 skills, 14 hooks across 7 events, 6 hard-enforced gates, and forge adapters for GitHub and GitLab, with machine-readable status output and safe upgrade mechanisms.

bbq is an MCP server that provides a dedicated browser UI for Claude Code grilling sessions, structuring multi-round interrogations with questions, options, and follow-up interactions into an easily scannable interface. It includes four skills (bbq, barbecue, churrasco, and bbq-offload) that move cognitively expensive code-discussion sessions into a dedicated UI with optional contextual panels for re-pitches, visual diagrams, and plain-language explanations.

This plugin guides users through a five-phase brand creation workflow—discover, strategy, verbal, visual, and guidelines—with compliance auditing at each stage via a phase-gate shell script. It enforces structured brand development practices and validates outputs before progression.

cc adds multi-session awareness to Claude Code by displaying active sessions working on the same project, tracking file edits to warn of conflicts, and enabling message passing between parallel sessions via a `/cc` command. It uses liveness detection on Claude Code's `/tmp` directories and stores session metadata locally to provide near-instant conflict detection without requiring external services.

cc-meta provides Claude Code meta-skills for synthesizing cross-project context, compacting verbose outputs, and maintaining session intelligence across work streams. It includes 9 skills that surface reasoning modes, extract learnings, orchestrate parallel agents, and auto-generate structured session summaries via hooks.

This Claude Code plugin enforces best practices and maintains memory across multiple concurrent Claude sessions on a single repository, coordinating work through hooks and checkpoints. It prevents conflicts and enforces consistency by capturing prompts, gating evidence, and reviewing commits across parallel development sessions.

Claude Crew is a multi-team agent harness that installs specialist agent profiles (mobile, backend, QA, product, frontend) with team-specific workflows, code review rules, security guardrails, and shared memory for engineering teams. Each profile provides slash commands and lifecycle hooks that orchestrate agents through structured SDLC stages while learning from session activity to improve over time.

Claude Dev Kit provides 8 meta-skills (skill-writer, hookify, plugin-dev, and others) that enforce structural contracts for building Claude Code tools, plus idempotent installation tooling for wiring settings and git hooks. It generates tools and audits other tools without requiring external APIs, using only Python 3.8+, PyYAML, and local filesystem access.

This Claude Code plugin routes small runtime judgments to TypeSafe's Jev System One model, which returns typed answers about prompt classification, model tier selection, rule violations, and transcript compaction without generating text. It monitors four hook events (UserPromptSubmit, PreToolUse, PostToolUse, Stop) and uses cached instruction files to judge edits against your own CLAUDE.md and AGENTS.md rules.

Clio is a project-memory plugin that organizes `.claude/` into structured docs for decided requirements, built artifacts, and work owed, reading these before each task so Claude asks clarifying questions instead of guessing. It uses append-only ledgers and a manual write loop—nothing is auto-recorded—requiring only bash and standard Unix tools.

coachline is a split-pane panel for Claude Code that analyzes your prompts in real-time, showing what could be improved and providing enhanced versions to copy, powered by Claude on your own subscription with no API key needed. It also identifies relevant skills and plugins from your collection, searches the web for related tools and documentation, and detects patterns across your conversation history to suggest new skills.

Compact-manager warns the Claude Code session before its context window fills, capturing the model's working state before compaction and reinjecting it afterward to maintain continuity across context boundaries. In optional managed mode, it automatically invokes /compact at the right moment by safely typing into tmux, verifying composer safety and turn boundaries before each keystroke.

console-kit is a Claude Code plugin that enables agents to interact with a web-based owner console protected by Cloudflare Access, allowing the owner to answer agent questions and guide deliberation rounds. The plugin includes 8 agents and 11 skills for project onboarding, answer processing, and locked answer integration, along with a server component installed via /console-kit:console-onboard.

Continuity Kit preserves Claude agent sessions across stops, crashes, or clears by recording git state, re-deriving commands, and verifying prior execution before resuming—plus doc-rollup for consolidating project history with automatic degradation at size thresholds. It requires only Python 3.8+ and PyYAML, uses bash for git operations, and hooks into SessionStart, Stop, and PreCompact events to inject handoffs and guard state without external APIs.

A peer messaging and coordination system for Claude Code sessions that lets developers discover teammates, send messages, and collaborate across different repositories and machines using scope-based addressing. It integrates with Claude Code via an MCP server and uses GitHub OAuth for authentication.

The coworker plugin turns Cowork into an autonomous project manager by delegating coding tasks to the local Claude Code CLI via an MCP server, exposing six tools for task submission, iteration, and result retrieval. It reduces orchestrator token usage by 93–98% by keeping raw code out of the main conversation and only sharing summaries and decisions.

craft is a feature-delivery pipeline plugin that orchestrates a multi-phase workflow (design → decisions → planning → implementation → review → refactoring → validation → documentation → PR) with gated transitions, per-repo customization via .claude/workflow.md, and native resumability across agent sessions. It enforces test-passing gates at every phase, captures design decisions as ADRs, and isolates work in git worktrees with role-specific agents managing each phase.

This plugin scaffolds, validates, tests, and submits Claude Code plugins to the official Anthropic marketplace without leaving Claude Code. It handles the full end-to-end workflow including GitHub hosting setup, marketplace form prefilling, and optional automated Cowork smoke testing via Computer Use.

Delamain coordinates long-running coding work by spawning and managing multiple Claude Code or Codex agents across chat sessions, each assigned distinct roles like coding, testing, review, and documentation. It provides shared memory through journals, inboxes, handoff records, and a progress console to keep work moving when coordinators change.

This plugin provides six skills for managing a complete software development workflow from planning through shipping, with a phase-gate shell script external tool to enforce process gates. It includes a PreToolUse hook to guide developers through structured development phases with built-in quality checks.

docko coordinates workspace slots across multi-agent sessions using hooks to manage session ownership, write protection, and teammate delegation. It provides commands and a skill for managing slot state and enforcing coordination rules without external service dependencies.

EEP provides eleven evidence-first engineering skills for Claude Code and Codex agents, including investigation, PR review, capacity analysis, and release readiness checking that push agents to verify deployed state and actual test results rather than assumptions. The plugin runs shell commands to gather facts and operates via skill triggers with PostToolUse and UserPromptSubmit hooks.

This Claude Code plugin implements a six-phase FP&A (Financial Planning & Analysis) process covering assessment, planning, forecasting, budgeting, modeling, and review through 11 utility skills. The plugin integrates with shell scripts and hooks into pre-tool-use events to guide financial workflows.

Foreman runs Claude Code as a five-role software team (architect, implementer, reviewer, qa, pm) under a lead that reports to you, with depth-based lifecycles, two approval gates, cost tracking, and state that survives crashes and compaction. It orchestrates work from intake through execution, verification, and handoff, with escalation triggers for ambiguous decisions and parallel task execution in git worktrees.

foreman is a Claude Code plugin that orchestrates feature development by having a main agent (foreman) review requirements, write plans, and delegate tasks to a subagent worker, then verify results and track progress. It manages the entire workflow from feature definition through contract approval, task execution, and documentation in a workbench folder.

goal2 provides two skills to manage long-running AI tasks with measurable completion criteria: `/goal2:goal` runs tasks immediately with Claude's goal engine verifying completion, while `/goal2:delaylocal` schedules tasks to run unattended after a 5-hour API quota reset and sends LINE notifications. The plugin enforces completion verification through predefined conditions, prevents premature termination, and supports immediate interruption or progress status checks.

GUIDE SDD provides host affordances for the spec-driven engineering method, vendoring a spine into your repo and managing gate banks, session lifecycle, and a persona-based edit guard that prevents Engineers from modifying tests. The plugin integrates via hooks (PreToolUse, PostToolUse, Stop, SessionEnd) to enforce role-based access control and detects unauthorized changes to test and gate files.

The harness plugin is a workflow governance engine that instantiates reusable AI discipline patterns (model dispatch, loss-limit circuit-breaker, delegation templates, knowledge protocols) into any project via `/harness:init`, creating a project-specific `.claude/harness/` governance layer that evolves independently from plugin updates. The engine separates universal patterns from project instances, ensuring instances are never overwritten and can grow their own rules from real incidents without carrying boilerplate from other projects.

herdr-panorama is an opt-in Claude Code plugin that visualizes a swarm of orchestrators and their subagents in a live graph view, recording agent lifecycle events and providing orchestrators with a report_thread MCP tool. It displays orchestrator status, spawned subagents, and work threads in an Argo-style graph interface, reading local transcripts without requiring external services.

The house-rules plugin enforces persistent repository conventions through vendored rule files, drift detection, branch guards, and pinned subagent configurations that bootstrap and sync automatically at session start. It provides skills to manage, revise, and maintain a centralized house-rules repository across Claude Code projects.

humblepowers provides ten calibrated process disciplines—fit-ranked tool dispatch, capacity routing, test-driven development, systematic debugging, brainstorming, verification, code-review reception, planned execution, and model selection—that replace persuasion-based activation with deterministic trigger descriptions and behavioral evals. The plugin ships with three dispatch hooks (UserPromptSubmit, PreToolUse, SubagentStop) that inject candidate skill hints and runs on a local `uv` environment without requiring external API keys.

instincts auto-learns durable rules from recurring lessons and surfaces them at every session start so Claude Code follows established patterns without relearning. It deduplicates and reinforces similar rules using a confidence model, and can promote raw learnings from the knowledge-loop plugin into high-confidence instincts that are shareable across projects.

Three on-demand Claude Code skills—ticket-workflow, hard-rules, and retrospective—that package the Juscribe job-board SOP with deterministic enforcement hooks to manage agent ticket lifecycle, estimation, labels, testing gates, and iteration reviews. Thirteen bash hooks provide hard blocks and soft nudges for rule enforcement across pre-commit gates, edit tracking, and state management.

This plugin builds a self-improving, folder-scoped knowledge loop that captures confidence-scored learnings from agents as they work, then automatically surfaces the most relevant past lessons at session start using hybrid TF-IDF + keyword search with recency decay and importance weighting. It also consolidates stale notes and evolves recurring lessons into draft reusable skills.