RAD-Claude-Skills

# RAD Claude Skills A curated marketplace of plugins for [Claude Code](https://docs.anthropic.com/en/docs/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, and domain-specific tools where they earn their place. Install everything at once or cherry-pick individual plugins. --- ## What's Here ``` 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-brainstormer/ # Anti-anchoring brainstorming — any topic, not just code │ ├── rad-codex/ # Delegation to the local OpenAI Codex CLI — work and cross-model review │ ├── rad-coolify-orchestrator/ # Coolify self-hosted PaaS management (MCP-backed) │ ├── rad-planner/ # Strictly-planning — risk-first, adversarial, mechanically-validated → docs/plan.md │ └── 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-writer/ # Writing — Claude.ai-only distribution (no longer a plugin) │ └── use-codex/ # Delegating work to the local OpenAI Codex CLI └── archive/ # Retired plugins & skills — reference only, not installable ``` --- ## Plugins vs Skills — Two Formats, Two Environments You'll notice some names appear in both `plugins/` and `skills/` (`rad-brainstormer`), 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](https://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. One plugin has a Claude.ai counterpart: `rad-brainstormer`. The other Claude.ai skills, `rad-writer` and `use-codex`, are distributed standalone — `rad-writer`'s matching plugin was retired. The table column **Works with** shows which environments each plugin supports. --- ## Why These Plugins? Claude Code handles most coding tasks well out of the box — but it doesn't know which MCP servers your project has wired up, where your project left off last session, 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`. --- ## Quick Install ### Option 1: Add as a Marketplace (recommended) Add the entire marketplace to Claude Code or Claude Desktop — browse and install any plugin, with automatic updates on sync. ```bash # 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-planner@rad-claude-skills claude plugin install rad-brainstormer@rad-claude-skills # ... any plugin from the list below # Update all installed plugins claude plugin marketplace update ``` ### Option 2: Install Directly from Git ```bash # 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-planner@rad-claude-skills claude plugin install rad-brainstormer@rad-claude-skills # ... any plugin from the list below ``` ### Verify Installation Start a new Claude Code session and run: ``` /skills ``` --- ## Where to Start Not sure which plugins to install first? These three deliver the most value across the widest range of projects: | Plugin | Why install it | Works with | |--------|---------------|-----------| | [rad-repo-manager](plugins/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-planner](plugins/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-brainstormer](plugins/rad-brainstormer/) | The brainstormer that doesn't anchor you — it draws out *your* thinking before offering any ideas, under enforced divergent/convergent discipline. Brainstorms anything, not just code. Four skills: `brainstorm-session` (quick pass or full session; SCAMPER, six hats, reverse, HMW, starburst and unblock available as modes), `idea-evaluation`, `five-whys`, `design-sprint` (produces the spec `/rad-planner:plan` pre-fills from). Output is one file, delivered where you choose. | CLI, Desktop, Claude.ai | 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`. --- ## Plugin Pipelines Some plugins are designed to chain. The most common pipeline for a new project: 1. **[rad-brainstormer](plugins/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`) 2. **[rad-planner](plugins/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 by `plan-lint.py` and adversarially reviewed by the `risk-assessor` agent. Later, `/rad-planner:replan` absorbs reality into the plan, and `/rad-planner:rescue` is the entry point when a project's state got away from you. 3. **[rad-repo-manager](plugins/rad-repo-manager/)** — `/startup` orients each session with a trust report; `/repo-init` builds the container on a fresh repo (`/adopt` for an existing one); `/wrapup` writes a clean handoff from git evidence (quick by default); `/ship` is the one-command close-out (scans → wrapup → commit → push → deploy-verify); `/repo-align` is the opt-in deep pass that catches drift. Format authority for the whole doc shelf (`references/shelf-spec.md`); reads the `docs/plan.md` that rad-planner writes. 4. **Review** — review the code you generate from the plan with Claude Code's built-in `/code-review`; for a second opinion from another model, `/rad-codex:review` sends the same diff to the local OpenAI Codex CLI. 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`. --- ## Plugins ### Workflow & Code Quality | Plugin | Skills | Agents | What It Does | Works with | |--------|--------|--------|-------------|-----------| | [rad-repo-manager](plugins/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-planner](plugins/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-codex](plugins/rad-codex/) | 2 | 1 | Drives the locally installed OpenAI Codex CLI (GPT-5.5) as a non-interactive sub-agent from Claude Code. Two skills: `/rad-codex:delegate` (hand off a coding, debugging, analysis, or bulk mechanical task) and `/rad-codex:review` (cross-model review of the working diff, a branch delta, or a specific commit, returned for Claude to verify). One `codex-worker` agent for parallel fan-out across worktrees. Calls the binary directly — no proxy detours, no stdin hangs. Requires the Codex CLI installed and authenticated. | CLI, Desktop | ### Productivity & Content | Plugin | Skills | Agents | What It Does | Works with | |--------|--------|--------|-------------|-----------| | [rad-brainstormer](plugins/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), `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 | ### Backend & Infrastructure | Plugin | Skills | Agents | What It Does | Works with | |--------|--------|--------|-------------|-----------| | [rad-coolify-orchestrator](plugins/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`](packages/coolify-mcp/) (36 tools, OpenAPI-spec-verified). | CLI, Desktop | | [rad-1password](plugins/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 | --- ## Claude.ai Skills Standalone skills designed for [claude.ai](https://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. One is a Claude.ai counterpart of a marketplace plugin (`rad-brainstormer`); one is Claude.ai-only after the matching plugin was retired (`rad-writer`). | Skill | Source | What It Does | |-------|--------|-------------| | [rad-writer](skills/rad-writer/) | Claude.ai-only (plugin retired) | Domain-aware writing and editorial review across 9 content types, AI pattern avoidance, voice profiling | | [rad-brainstormer](skills/rad-brainstormer/) | Counterpart of rad-brainstormer plugin | Facilitated ideation, SCAMPER/Six Hats/Five Whys, pre-mortem analysis, design sprint | | [use-codex](skills/use-codex/) | Standalone | Delegating work to the locally installed OpenAI Codex CLI — non-interactive runs, second opinions, PATH/shim troubleshooting on Windows | See [`skills/README.md`](skills/README.md) for import instructions and how these differ from the plugin versions. --- ## How It Works 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-repo-manager` installed: ``` You: "Where did we leave off?" Claude: [activates startup skill, reads the docs + git state, returns a trust report] You: "I'm done for now" Claude: [activates wrapup skill, rewrites docs/handoff.md from git evidence] ``` With `rad-brainstormer` installed: ``` You: "I need ideas for this — let's brainstorm" Claude: [activates brainstorm-session skill, draws out your thinking first] You: "Which of these ideas is best?" Claude: [activates idea-evaluation skill, you score first, then structured evaluation] ``` See each plugin's README for its full list of trigger phrases. --- ## Requirements - [Claude Code](https://docs.anthropic.com/en/docs/claude-code) CLI installed and authenticated - Internet access (for skills that fetch web content) - Some plugins have additional requirements noted in their READMEs --- ## Retired Plugins & Skills Plugins and skills that are no longer maintained live under `archive/` — `archive/plugins/` and `archive/skills/`. They stay in the repo so their references and prompts remain readable, but they are not part of the marketplace and `claude plugin install` will not find them. Copy what you need out of them; don't expect them to be updated. --- ## Contributing Found a bug? Have an idea for a new skill? See: - [Contributing Guide](CONTRIBUTING.md) — how to submit changes - [Code of Conduct](CODE_OF_CONDUCT.md) — community standards - [Security Policy](SECURITY.md) — reporting vulnerabilities - [Discussions](https://github.com/RadOrigin-LLC/RAD-Claude-Skills/discussions) — questions & ideas --- ## License [Apache License 2.0](LICENSE) — free to use, modify, and distribute. Includes patent protection and requires noting modifications. --- Built with Claude Code by [RAD](https://github.com/RadOrigin-LLC)