A curated marketplace of plugins for Claude Code — Anthropic's agentic coding tool. The lineup focuses on capabilities that add value beyond Opus's baseline competence: workflow lifecycle, MCP-backed live operations, structured planning, honest AI-pattern auditing, and domain-specific tools where they earn their place.
Install everything at once or cherry-pick individual plugins.
RAD-Claude-Skills/
├── packages/ # Standalone npm packages
│ └── coolify-mcp/ # @radoriginllc/coolify-mcp — MCP server for Coolify API
├── plugins/ # Claude Code CLI & Desktop plugins (multi-skill bundles)
│ ├── rad-1password/ # 1Password CLI workflows — secret rotation, env injection, vault ops
│ ├── rad-a11y/ # WCAG 2.2 AA accessibility toolkit
│ ├── rad-brainstormer/ # Anti-anchoring brainstorming — any topic, not just code
│ ├── rad-chrome-extension/ # MV3 Chrome extension development
│ ├── rad-code-review/ # Specialist review lanes + findings memory on the built-in engine
│ ├── rad-context-prompter/ # Prompt, loop & goal engineering across the AI platform catalog
│ ├── rad-coolify-orchestrator/ # Coolify self-hosted PaaS management (MCP-backed)
│ ├── rad-council/ # Multi-agent decision-debate council — advisors debate, vote, recommend
│ ├── rad-explain/ # Honest project explanation — 5 skills + 2 grounding/overpromise validators
│ ├── rad-para-second-brain/ # PARA second brain — organize, review, distill
│ ├── rad-planner/ # Strictly-planning — risk-first, adversarial, mechanically-validated → docs/plan.md
│ ├── rad-seo-optimizer/ # Complete SEO & AEO toolkit
│ └── rad-repo-manager/ # Repo manager for vibe coders — startup/wrapup/repo-init/repo-align + drift hooks
└── skills/ # Claude.ai skills (ZIP upload / Project Knowledge)
├── rad-brainstormer/ # Ideation — Claude.ai adaptation of rad-brainstormer
├── rad-seo-aeo-reviewer/ # SEO/AEO — Claude.ai adaptation of rad-seo-optimizer
└── rad-writer/ # Writing — Claude.ai-only distribution (no longer a plugin)
You'll notice some names appear in both plugins/ and skills/ (rad-brainstormer, plus rad-seo-optimizer ↔ rad-seo-aeo-reviewer), and that rad-writer lives only under skills/. They cover the same knowledge but are built for different environments:
plugins/ — Claude Code CLI & Claude Desktop
Full plugin bundles with multiple skills, autonomous agents, reference files, and automatic routing. They activate when you're working in a Claude Code session — they can read your filesystem, spawn subagents, and chain tools together. Install with claude plugin install.
skills/ — Claude.ai (the web app)
Single-file skills designed for claude.ai. Zip a skill's folder yourself and upload it via Settings > Customize > Skills, or use the files as Project Knowledge or conversation attachments. They consolidate plugin knowledge into one skill, use web search and URL fetching instead of filesystem tools, and output deliverables as artifacts. No CLI needed.
Two plugins have Claude.ai counterparts: rad-brainstormer and rad-seo-optimizer (as rad-seo-aeo-reviewer). A third Claude.ai skill, rad-writer, is distributed standalone — the matching plugin was retired (its project-narrative role moved to rad-explain). The table column Works with shows which environments each plugin supports.
Claude Code handles most coding tasks well out of the box — but it doesn't know which MCP servers your project has wired up, which review patterns catch AI-generated mistakes in your specific framework, or how to deterministically validate the implementation plan it just generated. These plugins add value Opus doesn't provide on its own: deterministic validators (Python scripts), MCP-backed live operations, structured workflow lifecycle, and domain-specific tools.
Each one installs in a single command and activates automatically when you ask Claude about relevant topics. No configuration, no manual invocation. Use any plugin on its own, or run /rad-repo-manager:startup in a new project — it's a quick read-only orientation (L0/L1 docs + git state + the mechanical scans, ending in a trust report); on a fresh repo it points you at /rad-repo-manager:repo-init, which builds the doc-model container (lean AGENTS.md with the stamped doc-model block, shims, docs/ + archive, handoff stub) and hands off to /rad-planner:plan.
Add the entire marketplace to Claude Code or Claude Desktop — browse and install any plugin, with automatic updates on sync.
# Add the marketplace
claude plugin marketplace add https://github.com/RadOrigin-LLC/RAD-Claude-Skills
# Install any plugin from the marketplace
claude plugin install rad-repo-manager@rad-claude-skills
claude plugin install rad-code-review@rad-claude-skills
claude plugin install rad-planner@rad-claude-skills
# ... any plugin from the list below
# Update all installed plugins
claude plugin marketplace update# Clone the repo
git clone https://github.com/RadOrigin-LLC/RAD-Claude-Skills.git
# Add the local clone as a marketplace
claude plugin marketplace add ./RAD-Claude-Skills
# Install any plugin
claude plugin install rad-repo-manager@rad-claude-skills
claude plugin install rad-code-review@rad-claude-skills
claude plugin install rad-planner@rad-claude-skills
# ... any plugin from the list belowStart a new Claude Code session and run:
/skills
Not sure which plugins to install first? These four deliver the most value across the widest range of projects:
| Plugin | Why install it | Works with |
|---|---|---|
| rad-repo-manager | A repo manager for vibe coders — a closed doc system where every kind of information has exactly one home and one update trigger. /startup (read-only trust report: every managed doc measured in commits-behind, ending with the next task), /wrapup (quick by default: handoff overwritten from git evidence + two append questions; --full adds the session-scoped reconcile), /ship (one-command close-out: scans → wrapup → commit → push → deploy-verify → branch sweep), /repo-init (greenfield container), /adopt (brownfield archaeology onto the doc model), /repo-align (opt-in deep pass — doc router, vocabulary lint, rules audit; proposed, never auto-applied). Hooks inject the handoff + a trust summary at session start, nudge on drift, checkpoint before compaction. Replaces rad-session. |
CLI, Desktop |
| rad-code-review | The specialist lanes and memory the built-in /code-review doesn't have. Invokes the built-in engine for general bug-finding, then adds: a mechanical hallucinated-imports validator (lockfile-verified across Python/JS/TS/Rust/Go, with a vendored slopsquat denylist), an AI-slop lane refreshed for agentic-era failures (test capitulation, deleted guards, hardcoded expected outputs), framework IDOR heuristics, a Supabase/Firebase BaaS-RLS lane with a reachability gate, stable CR-NNN finding IDs tracked across runs by a script (new/recurring/resolved), and a --security-deep launch-readiness pass with a no-false-assurance verdict. Never commits. |
CLI, Desktop |
| rad-planner | A planner built for solo devs who aren't formally trained engineers. It grills you first (a structured discovery interview — eight coverage areas driven to settled-or-explicitly-unknown, your project mirrored back for correction, assumptions proposed for confirm/deny), then writes a plan with a release ladder — Now (MVP/Beta, fully specced tasks) → Next (V1 outline) → Later (your end goal) — readable by you, executable by your coding agent. Four skills: /plan (greenfield), /rescue (project archaeology + a fresh plan for a repo that got away from you — assesses, never fixes), /replan (evidence-based updates that never delete history), /review-plan (quality audit). Can draft your PRD from your own interview answers, per-section confirmed. Mechanically lint-validated + adversarially risk-reviewed. |
CLI, Desktop |
| rad-explain | Honest project explanation for any repo. Five skills (narrate-project, elevator-pitch, draft-pitch, explain-document, ground-readme) generate audience-targeted external communications from internal artifacts. Two pure-stdlib Python validators (check-grounding, check-overpromise) run on every output — claims must trace to repo source; superlatives, vague-quantity, marketing fluff, and production-readiness assertions get flagged. No rad-planner dependency; works on any repo. |
CLI, Desktop |
After installing rad-repo-manager, run /rad-repo-manager:startup in your project — it reads the L0/L1 docs + git state, runs the mechanical scans, and briefs you with a trust report on where you are, what's next, and whether the docs are trustworthy. On a fresh repo it points you at /rad-repo-manager:repo-init to build the container, then /rad-planner:plan; an established repo without the doc model gets /rad-repo-manager:adopt.
Some plugins are designed to chain. The most common pipeline for a new project:
- rad-brainstormer — explore the problem space without being anchored by AI suggestions, converge on an idea, produce a design spec (
/rad-brainstormer:brainstorm-session→/rad-brainstormer:design-sprint) - rad-planner — turn the spec into an ordered implementation plan via the interview-driven, risk-first planning conversation. Writes one file,
docs/plan.md(release map Now/Next/Later, milestones, tasks, validation, risks); mechanically validated byplan-lint.pyand adversarially reviewed by therisk-assessoragent. Later,/rad-planner:replanabsorbs reality into the plan, and/rad-planner:rescueis the entry point when a project's state got away from you. - rad-repo-manager —
/startuporients each session with a trust report;/repo-initbuilds the container on a fresh repo (/adoptfor an existing one);/wrapupwrites a clean handoff from git evidence (quick by default);/shipis the one-command close-out (scans → wrapup → commit → push → deploy-verify);/repo-alignis the opt-in deep pass that catches drift. Format authority for the whole doc shelf (references/shelf-spec.md); reads thedocs/plan.mdthat rad-planner writes. - rad-code-review — review the code you generate from the plan (
/rad-code-review)
Each plugin stands alone — the pipeline is a suggestion, not a requirement. The boundary between design-sprint and plan is: design-sprint produces a spec (architecture, components, APIs), plan produces an ordered implementation plan — sequenced milestones with acceptance criteria, validation commands, guardrails, and risks — written as a single docs/plan.md.
| Plugin | Skills | Agents | What It Does | Works with |
|---|---|---|---|---|
| rad-repo-manager | 6 | 0 | A repo manager for vibe coders — a closed doc system (references/shelf-spec.md is the single source): a five-layer context stack (L0 AGENTS.md ≤40 lines + L1 docs/handoff.md ≤60 lines with a Deferred ledger, both injected every session by hook), a closed shelf of reference docs each created only when its trigger fires, one vocabulary (Goal → Release → Milestone → Task), one writer per file. Six skills: /startup (trust report in commits-behind + the next task), /wrapup (quick by default — handoff overwritten from git evidence + two append questions; --full adds the session-scoped reconcile), /ship (close-out chain: scans → wrapup → conventional commit → push → deploy-verify via the Coolify MCP when AGENTS.md declares a target, degrading gracefully → branch/worktree sweep; first ship runs the trait fit-out), /repo-init (greenfield container with the stamped doc-model block), /adopt (brownfield archaeology — L0–L2 drafted from evidence, commands verified by running them, every doc triaged onto the shelf, hands plan reconstruction to /rad-planner:rescue), /repo-align (deep pass — doc router, vocabulary lint, api.md route-diff, rules audit, size budgets; proposes everything, moves with git mv). Three non-blocking hooks (SessionStart identity banner + handoff injection + trust summary, Stop drift nudge, PreCompact checkpoint) and six pure-stdlib validators. Replaces rad-session. |
CLI, Desktop |
| rad-code-review | 1 | 0 | The specialist lanes and memory the built-in /code-review doesn't have — it invokes the built-in as the engine (quick/standard/deep → its effort levels), then adds: a mechanical hallucinated-imports validator (lockfile-verified across Python/JS/TS/Rust/Go, vendored denylist of documented malicious typosquats, did-you-mean suggestions, offline always), an AI-slop lane refreshed for agentic-era failures (test capitulation, deleted-guard regressions, weak-assertion tests, hardcoded expected outputs, scope-creep, XSS/log-injection sinks — every pattern sourced and labeled mechanical-vs-judgment), framework IDOR heuristics (Next.js server actions + middleware-is-not-a-boundary, Express/Fastify, Django, Rails, Go), a Supabase/Firebase BaaS-RLS lane (reachability gate, user_metadata escalation, publishable-vs-secret key model, do-NOT-flag list), deterministic findings memory (findings-index.py — stable CR-NNN IDs, new/recurring/resolved computed by script), and a --security-deep launch-readiness pass under a no-false-assurance contract. Fixes apply to the working tree only — never commits. Diff/branch/PR scope; whole-repo wants /code-review ultra. |
CLI, Desktop |
| rad-planner | 4 | 2 | A planner for solo devs who aren't formally trained engineers; strictly a planner (never writes implementation code). Method: a structured discovery interview (eight coverage areas — end goal, users, MVP, success criteria, constraints, assets, exclusions, danger zones — driven to settled-or-explicitly-unknown, mirror-back, proposed assumptions, ≤3 rounds), codegen-aware stack evaluation (stack-advisor + AI-native Golden Path matrix), goal-backward decomposition with size discipline, mechanical validation (plan-lint.py), then an adversarial risk-assessor pass against 14 documented anti-patterns (APPROVE/REVISE/RETHINK). Output: one docs/plan.md with a release map — Now (MVP/Beta, six-field task specs) / Next (V1 outline) / Later (end goal) — plus a plain-language layer for the human reader. One vocabulary — the naming ladder (Goal → Release → Milestone → Task), conforming to the repo's AGENTS.md doc-model block when present; discovery pre-fills from the repo and dated spec docs (docs/*-spec.md) and confirms instead of re-asking; /plan ends with the seed packet (stack decision appended to docs/decisions.md, cut features and stray ideas to docs/ideas.md). Four skills: /plan, /rescue (read-only project archaeology + evidence-led interview + fresh plan for a messy repo), /replan (evidence-based update; shipped work moves to ## Shipped, never deleted; parked ideas in docs/ideas.md get a fair hearing), /review-plan. Births docs/prd.md from your interview answers (per-section confirmed) when none exists; other durable changes surface as a paste-ready update-prompt. Quick path (skip stack agent, single risk pass) or full path — your choice at discovery. |
CLI, Desktop |
| rad-a11y | 6 | 1 | WCAG 2.2 AA accessibility — 4 reference skills (semantic HTML, ARIA, keyboard/focus, forms), 1 setup skill (a11y-testing wires up real axe via jest-axe + Playwright), 1 static-analysis skill (a11y-review) + autonomous reviewer agent. Every finding tagged [STATIC] / [HEURISTIC] / [NEEDS-MANUAL]; no Pass/Fail compliance verdict. Four pure-stdlib Python scripts (scan-jsx-patterns, check-tailwind-contrast with real WCAG sRGB math, check-target-size for WCAG 2.5.8, lint-aria wrapping eslint-plugin-jsx-a11y) run in Phase 0 before LLM judgment. Cross-model and stack-aware: Phase 0 + Phase 1 issued as a single parallel tool-call burst (Haiku falls back gracefully); Phase 8 stack slices only execute when the detected stack matches (React/Next/Astro/Tailwind/Radix/Headless UI), plain HTML projects skip Phase 8 entirely. |
CLI, Desktop |
| rad-chrome-extension | 9 | 1 | Chrome MV3 extensions — WXT, React, security, messaging, storage, service workers, CWS compliance | CLI, Desktop |
| Plugin | Skills | Agents | What It Does | Works with |
|---|---|---|---|---|
| rad-seo-optimizer | 12 | 3 | Full SEO toolkit — site audits, AEO/AI visibility, keyword research, competitor analysis, link building, schema, technical SEO | CLI, Desktop, Claude.ai |
| rad-brainstormer | 4 | 3 | The brainstormer that doesn't anchor you: it draws out your thinking before offering any ideas (research-backed anti-anchoring protocol), under enforced divergent/convergent discipline. Brainstorms anything — software, business, content, travel, creative. Four skills: brainstorm-session (two tiers — a quick pass with zero subagents for small bounded topics, or the full session; techniques as modes — SCAMPER, six hats, reverse, HMW, starburst, unblock), idea-evaluation (user scores first, always; high-stakes multi-lens decisions route to /rad-council:convene), five-whys, design-sprint (spec → hands off to /rad-planner:plan, which pre-fills from it). Three agents: live domain research (offered just-in-time), pre-mortem idea-challenger, spec-reviewer (inline self-review first, at most one dispatch). Output is one file, delivered where you choose — personal folder, project (as an explicitly transient doc), or chat only. |
CLI, Desktop, Claude.ai |
| rad-explain | 5 | 0 | Honest project explanation. Five skills (narrate-project, elevator-pitch, draft-pitch, explain-document, ground-readme) generate audience-targeted external communications from a project's internal artifacts. Two pure-stdlib Python validators (check-grounding, check-overpromise) gate every output — claims must trace to repo source, superlatives + vague-quantity + marketing fluff + unsupported production-readiness get flagged. Works on any repo; reads canonical docs/ if present, falls back to README + manifest + source structure. |
CLI, Desktop |
| rad-para-second-brain | 5 | 2 | PARA second brain — organize notes, run weekly reviews, progressive summarization, session handoffs, 12 favorite problems | CLI, Desktop |
| rad-council | 1 | 2 | Multi-agent decision-debate council. One skill, /convene: a Blue Hat orchestrator selects 3–5 advisors that reason under incompatible cognitive frameworks (The Contrarian, First Principles, The Vulcan, The Metric, …), they draft independently, blind peer-review + dot-vote, then a fresh-context chair synthesizes one ranked, confidence-rated recommendation with dissent preserved and a single concrete next step. Standard and quick modes; hard agent/round caps against runaway cost; Claude-only, no external API keys. Debates anything — repo plans, UX designs, product critiques, marketing, strategy. Two agents: council-advisor, council-chair. |
CLI, Desktop |
| rad-context-prompter | 3 | 1 | Prompt engineering — write, debug, and optimize prompts across the platform catalog in its tool-routing reference (chat/reasoning models, agentic IDEs incl. Claude Code and OpenAI Codex/AGENTS.md, image/video/voice/3D generators, workflow tools). Loop & goal engineering: author loop prompts, /goal/Goal Mode conditions, and long-horizon scaffolds, with check-goal.py linting goal specs against documented reward-hacking signatures (G1-G7). Decompiler for reverse-engineering existing prompts; F1-F8 debugger agent |
CLI, Desktop |
| Plugin | Skills | Agents | What It Does | Works with |
|---|---|---|---|---|
| rad-coolify-orchestrator | 9 | 1 | Coolify self-hosted PaaS — deployments, databases, security, CI/CD, troubleshooting, observability, infrastructure, live actions, status dashboard. 4 Python validators (lint-dockerfile, lint-compose, check-coolify-env, audit-cicd) run via the coolify-reviewer agent and auto-fire on Dockerfile/compose edits via a PostToolUse hook. Honest about what's experimental (Sentinel scope, Swarm, Caddy proxy, Railpack-NOT-yet-shipped). Bundles @radoriginllc/coolify-mcp (36 tools, OpenAPI-spec-verified). |
CLI, Desktop |
| rad-1password | 11 | 0 | End-to-end coverage of the 1Password CLI (op) — so Claude can use your secrets without you ever pasting plaintext into chat. Seven auto-triggered routers (1password-cli, op-secrets-injection, op-item-management, op-provisioning, op-ssh-keys, op-shell-plugins, op-service-accounts) plus four utility slash commands (/op-signin, /op-status, /op-find, /op-secret-template). All 8 commands and 11 management commands documented at the 1Password CLI reference are covered; flags cross-checked against op --help on v2.34.0. Honest about beta scope (op environment is beta-only and directed to in-app management). Requires 1Password CLI v2.x; biometric unlock or service-account token. |
CLI, Desktop |
Standalone skills designed for claude.ai. Zip a skill's folder and import it via Settings > Customize > Skills, add the files to a Project, or attach them to any conversation. Two are Claude.ai counterparts of marketplace plugins (rad-brainstormer, rad-seo-optimizer → rad-seo-aeo-reviewer); one is Claude.ai-only after the matching plugin was retired (rad-writer — see the retirement note above).
| Skill | Source | What It Does |
|---|---|---|
| rad-writer | Claude.ai-only (plugin retired) | Domain-aware writing and editorial review across 9 content types, AI pattern avoidance, voice profiling |
| rad-brainstormer | Counterpart of rad-brainstormer plugin | Facilitated ideation, SCAMPER/Six Hats/Five Whys, pre-mortem analysis, design sprint |
| rad-seo-aeo-reviewer | Counterpart of rad-seo-optimizer plugin | SEO audit (URL or GitHub mode), competitor research, content strategy, AI search visibility |
See skills/README.md for import instructions and how these differ from the plugin versions.
Once installed, skills activate automatically when you ask Claude about relevant topics. Each skill has specific trigger phrases — natural language patterns that tell Claude when to use that skill.
For example, with rad-a11y installed:
You: "Is this component accessible?"
Claude: [activates a11y-review skill, runs WCAG 2.2 AA review]
You: "Set up axe-core testing for my project"
Claude: [activates a11y-testing skill, scaffolds CI integration]
With rad-seo-optimizer installed:
You: /seo-audit https://mysite.com
Claude: [runs 6-phase SEO audit with scored report]
You: "How do I get recommended by ChatGPT?"
Claude: [activates aeo-optimizer skill, analyzes AI search visibility]
See each plugin's README for its full list of trigger phrases.
- Claude Code CLI installed and authenticated
- Internet access (for skills that fetch web content)
- Some plugins have additional requirements noted in their READMEs
Found a bug? Have an idea for a new skill? See:
- Contributing Guide — how to submit changes
- Code of Conduct — community standards
- Security Policy — reporting vulnerabilities
- Discussions — questions & ideas
Apache License 2.0 — free to use, modify, and distribute. Includes patent protection and requires noting modifications.
Built with Claude Code by RAD