Rhize Plugins for Claude Code: The Complete Guide

Rhize Plugins is a public Claude Code plugin marketplace by Rhize Media containing six plugins that extend Claude with specialized skills for SEO and AI-search optimization, Obsidian knowledge management, project launches, production development workflow, team operations, and skill governance. Alongside it, the @rhize/skill-forge npm package adds a supply-chain security gate for installing agent skills from any source.

We built every one of these plugins to run our own agency first. Each started as internal tooling — the SEO skills that audit our client sites, the workflow discipline we enforce on our production deploys, the hand-off pipeline we use to delegate work across the team — and was packaged into a plugin only after it had proven itself in daily use. This guide explains what each plugin does, when to reach for it, and how the pieces fit together. Each section links to a dedicated deep-dive article covering that plugin's skills, commands, and setup in full.

What Are Rhize Plugins?

Rhize Plugins is a curated collection of six Claude Code plugins distributed through a single public marketplace at github.com/Rhize-Media/rhize-plugins. Each plugin bundles related skills, slash commands, and (where needed) MCP server configuration, so Claude gains an expert workflow — not just a prompt — for a specific domain.

A Claude Code plugin is a package of skills (structured instructions Claude loads when a task matches), commands (slash commands you invoke directly), and optional hooks and MCP servers (live tool integrations). Installing a plugin is closer to onboarding a specialist than installing a library: the plugin decides when its expertise applies and brings its own tool access with it.

The marketplace convention is consistent across all six plugins. Every plugin ships a technical README.md (setup, environment variables, full skill inventory) and a plain-language GUIDE.md (when to use which skill, example prompts, troubleshooting). If you are evaluating a plugin, the GUIDE is the faster read; the README is the reference you return to during setup.

How Do You Install Rhize Plugins?

Installation takes one command and works in both Claude Code and Cowork. All six plugins become available from a single marketplace registration — you then install only the ones you need.

1. In Claude Code, run /plugin marketplace add https://github.com/Rhize-Media/rhize-plugins (in Cowork: Settings > Plugins > Add Marketplace with the same URL).
2. Install a plugin, for example /plugin install seo-aeo-geo@rhize-plugins.
3. Check that plugin's README for prerequisites — for example, seo-aeo-geo needs DataForSEO API credentials, and obsidian-second-brain needs Obsidian's Local REST API plugin. Several plugins work with no external credentials at all.

The Six Plugins at a Glance

seo-aeo-geo: SEO, AEO, and GEO Optimization

The seo-aeo-geo plugin turns Claude Code into a full-stack search optimization practitioner. It crawls sites, researches keywords, analyzes backlinks, tracks rankings, and audits AI-citation visibility using live DataForSEO data — then hands back reports or, where you have the codebase open, direct code fixes.

The plugin covers three distinct disciplines. SEO is classic ranking in search results. AEO (Answer Engine Optimization) targets being selected as the answer in surfaces like Google AI Overviews. GEO (Generative Engine Optimization) targets visibility in generative assistants like ChatGPT, Claude, and Perplexity. The /ai-visibility command checks whether those AI systems are actually citing your brand — a question traditional rank tracking cannot answer. The /code-seo-review command goes further than reporting: it writes actual Next.js and Sanity fixes for metadata, sitemaps, and JSON-LD structured data.

Commands compose into workflows — /keyword-research into /content-optimize into /rank-track — so the plugin closes the loop from research to fix to verification. It requires DataForSEO credentials (DATAFORSEO_USERNAME and DATAFORSEO_PASSWORD); the codebase-only nextjs-sanity-seo skill works without any external account. Read the full seo-aeo-geo plugin guide for every skill and command.

obsidian-second-brain: An AI-Assisted Knowledge System

The obsidian-second-brain plugin connects Claude Code to an Obsidian vault and turns it into a working second brain: nine skills and nine slash commands covering PKM methodology, note templates, vault health, semantic search, and web clipping, wired in through the Obsidian MCP server and CLI.

Three capabilities stand out in daily use. /vault-research runs a complete research pipeline — clip or search a source, summarize it, find related notes, log it in the daily note — in one command. /vault-recall is a "talk to your notes" interface built on qmd hybrid search (BM25 plus vector search plus LLM re-ranking) that answers natural-language questions with wikilink-cited synthesis, and flags contradictions between notes. /vault-align audits vault health across five dimensions and can fix or migrate what it finds, using link-safe moves.

It needs Obsidian running with the Local REST API plugin and an OBSIDIAN_API_KEY, plus the Obsidian CLI; web clipping and semantic search come from optional tools (Defuddle and qmd) and degrade gracefully when absent. The full obsidian-second-brain plugin guide walks through every skill and the complete setup.

project-launcher: From Idea to Scaffolded Project

The project-launcher plugin runs a six-phase pipeline that turns a rough project idea into a stress-tested specification and a ready-to-build directory: research, requirements interview, PRD plus visual plan, critical gap analysis, scaffolding, and a GSD v2 handoff.

What makes it different from "write me a PRD" prompting is the order of operations. It researches first — your Obsidian vault, your codebases, relevant MCP servers — and only asks the questions research could not answer. The /grill-prd command then attacks the draft PRD for failure modes, cost problems, and scalability gaps before anything gets scaffolded, producing a hardened PRD v2. Approval happens on a reviewable plan.mdx visual plan rather than a wall of requirement text.

A typical launch starts with a sentence — "I want to build a tool that syncs our Slack standup notes into Notion" — and ends with a scaffolded project a coding agent can execute against. The dedicated project-launcher plugin guide covers each phase and command in detail.

rhize-devflow: Production Discipline for AI-Assisted Development

The rhize-devflow plugin encodes production engineering discipline into seven skills and eleven commands, so Claude behaves like a careful production engineer rather than a prototyping assistant: session and context hygiene, error triage, cache-mutation consistency, Sentry instrumentation, Chrome DevTools debugging, and Sanity house style.

Its most distinctive capability is cross-layer mutation consistency checking — a scored analysis that catches the classic "backend cache tag doesn't match the frontend query key" bug behind most "I had to hard-refresh to see my change" reports. Its error-lifecycle skill correlates a Sentry error spike to the specific Vercel deploy and GitHub commit that caused it. And its compounding persistence layer has an independent verifier subagent grade completed work before any commit, paired with a STATE.md contract so every session leaves the next one better prepared.

It assumes a Next.js/Sanity/Payload/Supabase-on-Vercel stack and pairs naturally with an existing Sentry setup. The rhize-devflow plugin guide documents all seven skills, eleven commands, and the verifier workflow.

rhize-ops: Running a Team on Claude Code

The rhize-ops plugin handles the operational layer of agent-assisted teamwork: turning a working session into a structured delegation package, and measuring which installed skills actually earn their keep.

Its delegate-to-tom skill converts session context — optionally enriched with a Fireflies meeting transcript — into per-task Jira issues, Slack Canvases, and a tagged notification post complete with starter prompts and validation criteria for the person picking up the work. Its skill-dashboard renders a snapshot-based audit of skill usage: weekly trends, prune candidates, and direct-versus-subagent leverage. A /bump-version command handles plugin release chores — version sync, marketplace manifest, changelog — with a dry-run default.

This is the most agency-shaped plugin in the collection; we built it to run Rhize Media and published it because the delegation problem is universal to teams adopting Claude Code. The rhize-ops plugin guide shows the full hand-off pipeline with examples.

rhize-meta: Skill Governance

The rhize-meta plugin answers two questions every serious Claude Code user eventually hits: which external skills are safe to adopt, and how do I keep my own skills accurate as they age? It ships two skills — rhize-skill-forge for vetting and skill-refinement for self-improvement.

The vetting side runs a two-layer safety gate, including NVIDIA SkillSpector static and LLM-based scanning that hard-blocks HIGH and CRITICAL findings before anything is adopted. Rather than a binary install/skip, it applies a five-verb decision matrix — adopt, absorb, fork, reject, watch — so you can extract the useful patterns from an external skill without swallowing it whole. The refinement side watches usage: when the same one-off fix recurs across projects, it promotes the pattern into a shared default.

Ask it something like "Should we adopt this debugging skill, or does it duplicate what we already have?" and it runs the pipeline. See the rhize-meta plugin guide for the decision matrix and safety gates in depth.

Skill Forge: The npm Package for Safe Skill Installation

Skill Forge (@rhize/skill-forge) is a standalone npm CLI — separate from the plugin marketplace — that acts as a supply-chain security gate for agent skills. Instead of letting a one-line install drop unvetted third-party instructions into your agent's context, it routes every candidate through quarantine, profiling, a safety scan, overlap analysis, and a report, ending in an explicit promote, hold, or reject decision.

The problem it addresses is real and growing: public skill registries now distribute agent skills the way npm distributed packages a decade ago — one command, no vetting step, full trust. A malicious or sloppy skill is arbitrary instructions and scripts running inside your working agent. Skill Forge wraps the install command rather than replacing it, and it is source-agnostic: it accepts skills.sh slugs, any git URL, and local paths, all through the same pipeline. Since v0.6, the same gate applies to MCP servers, not just skills.

Get started with npx @rhize/skill-forge init, then vet any skill with npx @rhize/skill-forge add <source>. The package is dual-licensed (MIT core, commercial Pro tier). Inside Claude Code, the rhize-meta plugin wraps forge workflows conversationally — the CLI and the plugin share the same governance philosophy. The dedicated Skill Forge article covers the pipeline stage by stage.

How Do the Plugins and Skill Forge Fit Together?

The marketplace and the npm package solve complementary problems: the plugins give Claude new capabilities, and Skill Forge governs what capabilities you allow in from elsewhere. The six plugins are Rhize-authored and distributed through one trusted marketplace; Skill Forge is for everything outside it.

In practice, a team's stack looks like this: install the plugins that match your work (an SEO team takes seo-aeo-geo, a product team takes project-launcher and rhize-devflow), use rhize-ops to coordinate hand-offs across people, and put Skill Forge in front of any third-party skill or MCP server anyone wants to add. rhize-meta sits in the middle — the in-Claude governance layer that decides what external capability is worth adopting at all.