Claude Code Plugin Marketplace

65 production-ready plugins for Claude Code -- autonomous agents, power skills, anti-hallucination suite, smart hooks, and custom commands

Compatible with Claude Opus 4.6, Sonnet 4.6, and Haiku 4.5

What is this?

Claude Code is Anthropic's CLI tool for coding with AI. Plugins extend what Claude Code can do by adding specialized agents, skills, and automation hooks.

This marketplace gives you 53 ready-to-use plugins that turn Claude Code into an autonomous development powerhouse. Instead of telling Claude what to do step by step, you delegate entire tasks to specialized agents that know exactly how to handle them.

Before plugins:

You: "Read the auth module, check for SQL injection, review the error handling,
     look at the input validation, check the session management..."

After plugins:

You: "Run a security review on the auth module"
Claude: *security-analyst agent handles everything autonomously*

Quick Start

Prerequisites: Claude Code and Git installed.

macOS / Linux:

git clone https://github.com/a-ariff/ariff-claude-plugins.git
cd ariff-claude-plugins && bash scripts/install.sh

Windows (PowerShell):

git clone https://github.com/a-ariff/ariff-claude-plugins.git
cd ariff-claude-plugins; .\scripts\install.ps1

Done. Start a new Claude Code session and all 65 plugins are available.

What's Inside

65 Plugins in 4 Categories

ariff-claude-plugins/
|
|-- 24 Agents      autonomous workers that handle entire tasks
|-- 34 Skills      methodologies and knowledge you can apply on demand
|--  5 Hooks       automatic safeguards that run without you asking
|--  2 Commands    slash commands for common workflows
|
|-- includes 12-plugin Anti-Hallucination Suite

Agents (22) -- delegate entire tasks

Agents are autonomous workers. You give them a task, they figure out the approach, use tools, read files, and deliver results.

Category	Agents	What they do
Development	architect, backend-dev, frontend-dev, performance-engineer, qa-engineer, security-analyst, refactorer, autonomous-dev-assistant	Build, optimize, test, and secure code
Analysis	sequential-thinker, project-planner, analyzer, mentor	Plan, analyze, reason through problems
Safety	context-validator, intent-clarifier, pre-action-verifier, scope-boundary-checker, fact-checker, dependency-validator, rollback-planner	Validate before acting, catch mistakes early
Specialized	smithery-deployment-agent, smart-routing, setup-orchestrator	Deploy MCP servers, route to optimal models, configure environments

Skills (26) -- apply proven methodologies

Skills are knowledge and methodology files that Claude loads when relevant. They teach Claude how to approach specific types of problems.

Superpowers (9): brainstorming, writing-plans, executing-plans, subagent-driven-development, verification-before-completion, root-cause-tracing, defense-in-depth, when-stuck, using-superpowers

Development (12): github, plugin-creator, plugin-checker, canvas-api, api-docs-generator, ci-cd-helper, code-reviewer, commit-message-generator, error-explainer, performance-optimizer, pr-analyzer, refactor-assistant

Testing (3): security-scanner, tdd-workflow, test-writer

Debugging (2): systematic-debugger, memory-sync

Hooks (3) -- automatic safeguards

Hooks run automatically at specific points during Claude's workflow. You don't invoke them -- they watch and act.

Hook	Event	What it does
assumption-checker	PreToolUse	Warns when Claude makes assumptions instead of checking
memory-sync	Stop	Prompts to save learnings at session end
hooks-reference	PreToolUse	Reference implementation for building your own hooks

Anti-Hallucination Suite (12 plugins) -- stop AI from guessing

A complete system to prevent Claude from making things up. Hooks catch problems automatically, agents cross-verify claims, and skills teach verification methodology.

Why this matters: AI can confidently state things that aren't true -- wrong file paths, invented function names, assumed behavior. These plugins catch that before it reaches you.

Plugin	Type	What it does
hallucination-guard	Hook	Scans every response for speculative language and unverified claims
answer-validator	Hook	Checks that tool outputs match the claims Claude makes about them
truth-finder	Agent	Cross-references claims against actual code, docs, and git history
answer-analyzer	Agent	Reviews Claude's own response for accuracy before delivery
anti-hallucination	Skill	Complete methodology: verify before claiming, cite before asserting
cross-checker	Skill	Verify from multiple angles: code, tests, git, docs, config
source-verifier	Skill	Every claim must have a file:line citation or be flagged
confidence-scorer	Skill	Assigns 0-100 confidence score to each claim
citation-enforcer	Skill	Forces file:line references for every code claim
uncertainty-detector	Skill	Catches when Claude is guessing but sounding certain
output-auditor	Skill	4-angle review: accuracy, logic, completeness, safety
context-grounding	Skill	Forces reading actual code before making claims about it

Commands (2) -- slash commands

Command	Usage	What it does
deep-search	`/deep-search "query"`	Multi-source semantic search across GitHub, Reddit, docs
task-folder-manager	`/task-folder-manager`	Create dated, organized task folders

How to Install (Step by Step)

This guide assumes you've never installed a Claude Code plugin before. Pick your platform below.

Step 1: Make sure Claude Code is installed

Open any terminal and run:

claude --version

If you see a version number (e.g., 2.1.76), you're good. If not, install Claude Code first from claude.ai/code.

Step 2: Clone this repository

git clone https://github.com/a-ariff/ariff-claude-plugins.git
cd ariff-claude-plugins

Step 3: Run the installer for your platform

macOS / Linux (Terminal, iTerm, Warp)

bash scripts/install.sh

Windows (PowerShell)

# Run from PowerShell (not CMD)
cd ariff-claude-plugins

# Create plugin directories
$claudeDir = "$env:USERPROFILE\.claude"
New-Item -ItemType Directory -Force -Path "$claudeDir\agents"
New-Item -ItemType Directory -Force -Path "$claudeDir\skills"
New-Item -ItemType Directory -Force -Path "$claudeDir\hooks"
New-Item -ItemType Directory -Force -Path "$claudeDir\commands"
New-Item -ItemType Directory -Force -Path "$claudeDir\scripts"

# Copy all plugins
Get-ChildItem plugins -Directory | ForEach-Object {
    $plugin = $_
    # Agents
    if (Test-Path "$($plugin.FullName)\agents") {
        Copy-Item "$($plugin.FullName)\agents\*.md" "$claudeDir\agents\" -Force
    }
    # Skills (directories)
    if (Test-Path "$($plugin.FullName)\skills") {
        Get-ChildItem "$($plugin.FullName)\skills" -Directory | ForEach-Object {
            $dest = "$claudeDir\skills\$($_.Name)"
            New-Item -ItemType Directory -Force -Path $dest | Out-Null
            Copy-Item "$($_.FullName)\*" $dest -Force
        }
        # Skills (flat .md files)
        Get-ChildItem "$($plugin.FullName)\skills\*.md" -ErrorAction SilentlyContinue | ForEach-Object {
            $skillName = $_.BaseName -replace '\.skill$',''
            $dest = "$claudeDir\skills\$skillName"
            New-Item -ItemType Directory -Force -Path $dest | Out-Null
            Copy-Item $_.FullName "$dest\SKILL.md" -Force
        }
    }
    # Hooks
    if (Test-Path "$($plugin.FullName)\hooks\hooks.json") {
        Copy-Item "$($plugin.FullName)\hooks\hooks.json" "$claudeDir\hooks\$($plugin.Name)-hooks.json" -Force
    }
    # Commands
    if (Test-Path "$($plugin.FullName)\commands") {
        Copy-Item "$($plugin.FullName)\commands\*.md" "$claudeDir\commands\" -Force -ErrorAction SilentlyContinue
    }
    # Scripts
    if (Test-Path "$($plugin.FullName)\scripts") {
        Copy-Item "$($plugin.FullName)\scripts\*" "$claudeDir\scripts\" -Force -ErrorAction SilentlyContinue
    }
    Write-Host "  ok  $($plugin.Name)" -ForegroundColor Green
}

Write-Host "`nInstalled all plugins to $claudeDir" -ForegroundColor Cyan

Windows (WSL / Git Bash)

# If using WSL or Git Bash, the bash script works directly
bash scripts/install.sh

VS Code Terminal

Works with any terminal profile in VS Code:

Open VS Code
Open terminal: Ctrl+`` (backtick) or View > Terminal
Select your terminal profile (bash, PowerShell, or zsh)
Run the commands for your platform above

If your VS Code terminal is PowerShell, use the PowerShell instructions. If your VS Code terminal is bash/zsh, use the macOS/Linux instructions.

Windows Terminal

Windows Terminal supports multiple profiles. Pick the one that matches:

PowerShell tab: Use the PowerShell instructions above.

Git Bash tab: Use bash scripts/install.sh

WSL tab (Ubuntu/Debian): Use bash scripts/install.sh

CMD tab: Not recommended. Switch to PowerShell or Git Bash.

Step 4: Verify it worked

Start a new Claude Code session:

claude

Then type:

/browse

You should see all 65 plugins listed. If you see them, installation is complete.

How it works

    You clone the repo          Install script copies          Claude Code
    to your machine             components to ~/.claude/       reads them
                                (or %USERPROFILE%\.claude\
                                 on Windows)

    ariff-claude-plugins/       ~/.claude/
    |-- plugins/                |-- agents/     (22 files)
    |   |-- architect/    -->   |-- skills/     (26 dirs)
    |   |-- security/     -->   |-- hooks/      (3 configs)
    |   |-- debugger/     -->   |-- commands/   (2 files)
    |   |-- ...53 total         |-- scripts/    (hook scripts)
    |                           |
    |-- scripts/                Claude Code loads these
    |   |-- install.sh          automatically on startup
    |   |-- install.ps1

Install a single plugin

Don't want all 65? Install just what you need:

macOS / Linux:

bash scripts/install.sh --plugin architect
bash scripts/install.sh --plugin security-analyst

Windows PowerShell (single plugin):

# Example: install just the architect agent
$claudeDir = "$env:USERPROFILE\.claude\agents"
New-Item -ItemType Directory -Force -Path $claudeDir | Out-Null
Copy-Item plugins\architect\agents\*.md $claudeDir -Force

Updating

When new plugins are added:

macOS / Linux:

cd ariff-claude-plugins
git pull origin main
bash scripts/install.sh

Windows PowerShell:

cd ariff-claude-plugins
git pull origin main
# Re-run the PowerShell install block from Step 3

Uninstalling

macOS / Linux:

bash scripts/install.sh --uninstall

Windows PowerShell:

Remove-Item -Recurse -Force "$env:USERPROFILE\.claude\agents"
Remove-Item -Recurse -Force "$env:USERPROFILE\.claude\skills"
Remove-Item -Recurse -Force "$env:USERPROFILE\.claude\hooks"
Remove-Item -Recurse -Force "$env:USERPROFILE\.claude\commands"
Remove-Item -Recurse -Force "$env:USERPROFILE\.claude\scripts"

Troubleshooting

Problem	Solution
`claude: command not found`	Install Claude Code first from claude.ai/code
`git: command not found`	Install Git from git-scm.com
Plugins don't show in `/browse`	Restart Claude Code (close and reopen)
Permission denied on macOS	Run `chmod +x scripts/install.sh` first
PowerShell execution policy	Run `Set-ExecutionPolicy -Scope CurrentUser RemoteSigned`
WSL can't find ~/.claude	Make sure you're running Claude Code inside WSL, not Windows

Usage Guide

Using Agents

Agents are the most powerful feature. Describe what you want and Claude delegates to the right agent.

Example workflow:

+-------------------+     +-------------------+     +-------------------+
|                   |     |                   |     |                   |
|  You: "review     |---->|  Claude selects   |---->|  security-analyst |
|  this code for    |     |  security-analyst |     |  reads code,      |
|  vulnerabilities" |     |  agent            |     |  checks OWASP,    |
|                   |     |                   |     |  reports findings  |
+-------------------+     +-------------------+     +-------------------+

More examples:

"Design a caching layer for my high-traffic API"
  -> architect agent handles system design

"Review this code for security vulnerabilities"
  -> security-analyst agent runs a full review

"Optimize this database query that's taking 3 seconds"
  -> performance-engineer agent profiles and fixes it

"Plan the implementation for this new feature"
  -> project-planner agent breaks it down into steps

"Help me understand how this authentication flow works"
  -> mentor agent explains at your level

Using Skills

Skills are invoked when Claude recognizes a relevant situation, or you can ask directly:

"Use the systematic-debugger skill to find this memory leak"
"Apply the brainstorming skill to generate API design alternatives"
"Use verification-before-completion for this deployment"

Using Commands

Slash commands for quick actions:

/deep-search "react server components best practices"
/task-folder-manager --name "feature-auth-rewrite"

Using Hooks

Hooks run automatically. No action needed from you.

+------------------+     +--------------------+     +------------------+
|                  |     |                    |     |                  |
|  Claude is about |---->|  assumption-checker|---->|  "Warning: you   |
|  to use a tool   |     |  hook fires        |     |  assumed X, did  |
|                  |     |  (PreToolUse)      |     |  you verify it?" |
+------------------+     +--------------------+     +------------------+

Architecture

Plugin loading flow

flowchart TD
    A["You start Claude Code"] --> B["Claude reads ~/.claude/"]
    B --> C["agents/*.md"]
    B --> D["skills/*/SKILL.md"]
    B --> E["hooks/*.json"]
    B --> F["commands/*.md"]

    C --> G["Loaded on demand\nwhen task matches"]
    D --> H["Descriptions loaded\nfull content on invoke"]
    E --> I["Always active\nfires on matching events"]
    F --> J["Available as\n/slash-commands"]

    style A fill:#4CAF50,color:#fff
    style B fill:#2196F3,color:#fff
    style G fill:#FF9800,color:#fff
    style H fill:#FF9800,color:#fff
    style I fill:#f44336,color:#fff
    style J fill:#9C27B0,color:#fff

Plugin distribution

pie title 65 Plugins by Category
    "Agents (24)" : 24
    "Skills (34)" : 34
    "Hooks (5)" : 5
    "Commands (2)" : 2

Install flow

flowchart LR
    A["git clone"] --> B["cd ariff-claude-plugins"]
    B --> C{Your OS?}
    C -->|macOS/Linux| D["bash scripts/install.sh"]
    C -->|Windows| E[".\scripts\install.ps1"]
    C -->|WSL| D
    D --> F["~/.claude/"]
    E --> G["%USERPROFILE%\.claude\"]
    F --> H["65 plugins ready"]
    G --> H

    style A fill:#4CAF50,color:#fff
    style H fill:#4CAF50,color:#fff
    style C fill:#2196F3,color:#fff

Agent workflow

sequenceDiagram
    participant You
    participant Claude
    participant Agent

    You->>Claude: "review this code for vulnerabilities"
    Claude->>Claude: Selects security-analyst agent
    Claude->>Agent: Delegates task
    Agent->>Agent: Reads code files
    Agent->>Agent: Checks OWASP patterns
    Agent->>Agent: Analyzes attack surface
    Agent->>Claude: Returns findings
    Claude->>You: Structured security report

Plugin structure

Every plugin follows this structure:

my-plugin/
  .claude-plugin/
    plugin.json          # manifest (name, version, description)
  agents/                # agent definitions (markdown)
  skills/                # skill definitions (markdown)
  hooks/
    hooks.json           # hook event configuration
  commands/              # slash command definitions
  scripts/               # shell scripts for hooks

Supported hook events (22 total)

Category	Events
Session	SessionStart, SessionEnd
User Input	UserPromptSubmit
Tool Use	PreToolUse, PostToolUse, PostToolUseFailure, PermissionRequest
Completion	Stop, SubagentStop, TaskCompleted, TeammateIdle
Context	PreCompact, PostCompact, InstructionsLoaded
Config	ConfigChange
Worktree	WorktreeCreate, WorktreeRemove
MCP	Elicitation, ElicitationResult
System	Notification

Compatibility

Requirement	Details
Claude Opus 4.6	Full support (1M context)
Claude Sonnet 4.6	Full support (1M context)
Claude Haiku 4.5	Full support (200k context)
Claude Code version	2.1+ recommended
Operating systems	macOS, Linux, Windows (WSL)
Git worktree isolation	Supported
MCP integration	Supported (stdio, HTTP, SSE)

Statistics

Metric	Count
Total plugins	65
Agents	24 (37%)
Skills	34 (52%)
Hooks	5 (8%)
Commands	2 (3%)
Anti-hallucination suite	12 (included in counts above)
Plugin component types	6 (agents, skills, commands, hooks, MCP servers, LSP servers)
Supported hook events	22
Supported models	3 (Opus 4.6, Sonnet 4.6, Haiku 4.5)
Install time	< 30 seconds

Documentation

Guides (start here)

Agents Guide -- what agents are, all 24 agents with descriptions and examples
Skills Guide -- what skills are, all 34 skills with descriptions and examples
Hooks Guide -- what hooks are, all 22 supported events, how to create your own
Commands Guide -- what commands are, all 2 commands with usage

Reference

Categories Overview -- quick comparison of all plugin types
Plugin Structure -- how to build your own plugins
Quick Start -- fast setup (one page)
Changelog -- version history
Contributing -- how to contribute plugins
Setup Verification -- troubleshooting

Use Cases

For solo developers

Delegate code reviews to the security-analyst and code-reviewer
Use project-planner before starting any feature
Let systematic-debugger find root causes
Have architect agent design your system before you code

For teams

Standardize workflows with shared skills
Safety checker agents catch mistakes before they ship
QA engineer agent handles test strategy
Plugin-creator skill helps build team-specific plugins

For students

Mentor agent explains concepts at your level
Canvas API skill integrates with university LMS
Sequential-thinker breaks complex problems into steps
Writing-plans skill teaches you to plan before coding

Contributing

Contributions welcome. See CONTRIBUTING.md.

Quick contribution:

Fork this repository
Create your plugin in plugins/your-plugin/
Run bash scripts/validate-plugin.sh plugins/your-plugin
Submit a pull request

Why this marketplace?

Feature	This marketplace	Typical repos
Production-tested	Yes, 65 plugins	5-10 experimental plugins
Documentation	Full guides, visual diagrams, examples	Basic README
Safety layer	7 checker agents + 5 hooks	None
Model support	Opus 4.6, Sonnet 4.6, Haiku 4.5	Single model
One-line install	`bash scripts/install.sh`	Manual file copying
Cross-device sync	Git-based, works with any cloud storage	Not supported
Updates	`git pull && bash scripts/install.sh`	Manual

License

MIT License -- see LICENSE for details.

Links

Repository: https://github.com/a-ariff/ariff-claude-plugins
Issues: https://github.com/a-ariff/ariff-claude-plugins/issues
Author: @a-ariff

If this marketplace is useful to you, consider giving it a star. It helps others find these plugins.

Name		Name	Last commit message	Last commit date
Latest commit History 20 Commits
.claude-plugin		.claude-plugin
.github		.github
docs		docs
plugins		plugins
scripts		scripts
.gitignore		.gitignore
CHANGELOG.md		CHANGELOG.md
CONTRIBUTING.md		CONTRIBUTING.md
GITHUB_TOPICS.md		GITHUB_TOPICS.md
LICENSE		LICENSE
QUICKSTART.md		QUICKSTART.md
README.md		README.md
SETUP-COMPLETE.md		SETUP-COMPLETE.md

Folders and files

Latest commit

History

Repository files navigation

Claude Code Plugin Marketplace

What is this?

Quick Start

What's Inside

65 Plugins in 4 Categories

Agents (22) -- delegate entire tasks

Skills (26) -- apply proven methodologies

Hooks (3) -- automatic safeguards

Anti-Hallucination Suite (12 plugins) -- stop AI from guessing

Commands (2) -- slash commands

How to Install (Step by Step)

Step 1: Make sure Claude Code is installed

Step 2: Clone this repository

Step 3: Run the installer for your platform

Step 4: Verify it worked

How it works

Install a single plugin

Updating

Uninstalling

Troubleshooting

Usage Guide

Using Agents

Using Skills

Using Commands

Using Hooks

Architecture

Plugin loading flow

Plugin distribution

Install flow

Agent workflow

Plugin structure

Supported hook events (22 total)

Compatibility

Statistics

Documentation

Guides (start here)

Reference

Use Cases

For solo developers

For teams

For students

Contributing

Why this marketplace?

License

Links

About

Topics

Resources

License

Contributing

Uh oh!

Stars

Watchers

Forks

Releases

Packages 0

Uh oh!

Uh oh!

Contributors

Uh oh!

Languages

Packages