Plan a project before you write code — and re-plan it as reality unfolds. Built for solo developers who aren't formally trained engineers: it interrogates you until it actually understands what you're building, then produces a plan a moderately experienced vibe coder can read AND a coding agent can execute. Strictly a planner — it never writes implementation code. The method is interview-driven, risk-first, adversarially-reviewed, and mechanically-validated: - The grilling: a structured discovery interview — eight coverage areas (end goal, users, MVP, success criteria, constraints, assets, exclusions, danger zones), each driven to settled-or-explicitly-unknown; the project mirrored back for correction; assumptions proposed for confirm/deny. Capped at 3 rounds so it stays fast. - The release ladder: every plan anchors to your end goal via a Now / Next / Later release map — Now (MVP/Beta, fully specced tasks), Next (V1 milestone outline), Later (end-goal themes). Detail decays with distance by design; pulling the next horizon into detail is a /replan event. - Written for two readers: a plain-language layer (how-to-read note, release map, 'After this ships' lines) for you; six-field task blocks (objective, files, dependencies, done-when, validation, rollback) for the coding agent. - Codegen-aware stack evaluation (AI-native Golden Path matrix), goal-backward decomposition, risk-first sequencing with size discipline. - Mechanical validation via `plan-lint.py` (required sections incl. the release map, per-task fields, dependency resolution + cycles, vague language) — a real pass/fail check, not the model grading itself. - Adversarial review via the `risk-assessor` agent against 14 documented anti-patterns (APPROVE / REVISE / RETHINK; iterative on the full path, single-pass on the quick path you can choose at discovery). Four skills — two doors in, one maintained plan: - `/plan` — greenfield or a clear next effort: the six-phase conversation → `docs/plan.md`. - `/rescue` — a project in an unclear state: read-only archaeology (code + git evidence), evidence-led interview (keep/cut/unknown per piece), then a fresh release-map plan from where the project actually is. Assesses and plans; never fixes, runs, or deletes code. - `/replan` — evidence-based plan update: marks shipped work from git + handoff (moved to a `## Shipped` section — history preserved, never deleted), re-baselines the rest, pulls the next horizon into detail when Now ships. - `/review-plan` — two-layer quality audit of an existing plan (mechanical lint + adversarial risk review). The PRD exception: when `docs/prd.md` is missing or skeletal, the planner offers to draft it — each section written from your own interview answers, applied only on per-section confirmation. After that birth the PRD is yours (rad-repo-manager keeps it fresh); the planner never edits an existing PRD. Other durable-doc changes go into a paste-ready `docs/[date]-update-prompt.md` for you to apply — durable docs stay under your control. Pairs with rad-repo-manager (which maintains plan.md status and PRD freshness between plans); works standalone. Two agents: `stack-advisor`, `risk-assessor`.
Reviews implementation plans for anti-patterns, missing failure states, TDD gaps, context management issues, and architectural risks. Use when reviewing a plan before approval, when the user says "review my plan for risks", "check this plan", "what could go wrong", "audit my implementation plan", or when the `/plan` workflow needs a risk assessment before presenting the plan to the user. <example> Context: User has a plan and wants it reviewed before execution user: "Review my implementation plan for risks before I start coding" assistant: "I'll use the risk-assessor agent to audit the plan for anti-patterns and missing failure states." </example> <example> Context: User concerned about potential issues user: "What could go wrong with this plan? Check it for problems." assistant: "I'll use the risk-assessor agent to run a comprehensive risk assessment." </example>
Evaluates and recommends technology stacks using the AI-Native Golden Path proficiency matrix. Uses Context7 MCP and web search to verify current framework versions, features, and compatibility. Use when the user says "what stack should I use", "evaluate my tech stack", "recommend a stack for", "is this the right framework", "compare frameworks", or when the `/plan` workflow needs a stack evaluation for a new project. <example> Context: User starting a new project and unsure about tech stack user: "What stack should I use for a real-time dashboard app?" assistant: "I'll use the stack-advisor agent to evaluate the best stack for your project." </example> <example> Context: User wants to compare framework options user: "Should I use Next.js or Astro for this project?" assistant: "I'll use the stack-advisor agent to compare those frameworks against your requirements." </example>
This skill should be used when the user says "plan my project", "create an implementation plan", "help me architect this", "I need a plan before coding", "let's plan before we build", "plan this feature", "break this down into tasks", "map out the work", "create a project plan", "plan this app", or wants a structured, risk-first implementation plan before writing any code. Also trigger proactively when a user describes a non-trivial project or feature and appears ready to start coding without a plan. Runs a structured discovery interview, builds a release map (MVP/Beta now, V1 next, end goal later), and produces a single plan file (`docs/plan.md`). Can draft `docs/prd.md` from the interview answers with per-section confirmation when none exists; other durable docs surface as an update-prompt for the user to apply.
This skill should be used when the user says "replan", "update the plan", "re-baseline the plan", "the plan is out of date", "we shipped the MVP — what's next", "mark this milestone done", "the plan doesn't match reality anymore", "pull the next version into the plan", "adjust the plan", or when an existing `docs/plan.md` has diverged from what actually got built. Evidence-based plan update: reads git history + docs/handoff.md to mark shipped work (history preserved, never deleted), re-baselines remaining tasks, and pulls the next release-map horizon into detailed milestones when the current one is done. Re-lints and runs a single risk pass; nothing is final until the user approves.
This skill should be used when the user says "rescue this project", "this repo is a mess", "help me out of this", "I don't know where this project stands", "get this back on track", "untangle this project", "I abandoned this and want to restart", "figure out what state this is in", or has an existing project with unclear status, missing or garbage docs, and no trustworthy plan. Runs project archaeology (evidence-based state assessment from code + git, no code changes), reconstructs intent through the discovery interview, hands structure work to rad-repo-manager, drafts a PRD from the answers if none exists, and produces a fresh release-map plan from wherever the project actually is. It assesses and plans — it never fixes, runs, or deletes code.
This skill should be used when the user says "review my plan", "audit this plan", "check my implementation plan", "is this plan complete", "what's missing from my plan", "validate my plan", "plan review", "check plan quality", "risk review", "check dependencies", "are there any risks in my plan", or has an existing plan (`docs/plan.md`) that needs a quality audit before execution begins.
Own this plugin?
Verify ownership to unlock analytics, metadata editing, and a verified badge. GitHub access is read-only (username + org membership).
Sign in to claimBased on adoption, maintenance, documentation, and repository signals. Not a security audit or endorsement.
Codebase-scoped SEO/AEO tooling for Claude Code with four pure-stdlib Python validators that turn the plugin's static-analysis claims into deterministic checks: `audit-ai-access.py` (per-AI-bot robots.txt allow/block matrix classed training vs citation — GPTBot, ClaudeBot, Google-Extended, CCBot vs OAI-SearchBot, ChatGPT-User, Claude-SearchBot/User, PerplexityBot/User, Bingbot, Googlebot — plus llms.txt existence/format check, Content-Signal/RSL/noai detection, JS-dependence heuristic, and optional CDN-block UA probing), `validate-jsonld.py` (extracts JSON-LD from HTML and framework source including dangerouslySetInnerHTML/set:html/template-literal forms, validates against ~20 SEO-impactful schema.org types, honest dynamic_jsonld findings for unverifiable JS-built blocks), `audit-meta-tags.py` (title/description lengths, canonical shape, charset, viewport, robots sanity, Open Graph 5-prop + Twitter Card 4-prop coverage, hreflang x-default), `check-broken-links.py` (parallel HEAD scanner with GET-Range fallback; URL list / sitemap / HTML-root inputs). Plus knowledge skills for AEO/GEO content optimization (with AI crawl-access gate and Lighthouse Agentic Browsing awareness), keyword ideation, content strategy, schema generation with 2026 rich-result deprecation awareness (FAQ/HowTo retired), E-E-A-T, and observable competitive research. Honest scope: does NOT measure numerical Core Web Vitals, keyword volumes, backlink profiles, or actual AI citation rates — those require Path B MCP integrations documented in references/CAPABILITIES.md.
MV3 Chrome extension development standards (WXT, React, TypeScript) with two pure-stdlib Python validators that catch what LLM eyeballing misses. Skills cover architecture, MV3 security (CSP, remote code ban, content script isolation), permission minimization and CWS compliance, typed messaging, storage selection, service worker lifecycle, React UI patterns, testing, and Chrome Web Store troubleshooting. The chrome-ext-reviewer agent runs two validators before LLM judgment: `audit-manifest.py` (manifest.json audit for MV3 compliance, permission overreach, weak CSP, web_accessible_resources scoping, MV2 leftovers, CWS-rejection causes; auto-discovers WXT `.output/` build manifests) and `scan-mv3-violations.py` (greps source for CSP-banned `eval` / `new Function` / `setTimeout('string')`, remote `<script src="http">` and dynamic imports of remote URLs, MV2-only `chrome.tabs.executeScript` / `chrome.browserAction` / `chrome.extension.getBackgroundPage`, blocking webRequest listeners, optional DOM-risk `innerHTML` / `document.write`). Both emit findings with severity and specific fix recommendations. Pure stdlib Python 3.8+.
3-role adversarial code review for Claude Code — Opus default, Sonnet/Haiku compatible. Parallel tool-call pipeline, JSON-first subagent output, compaction-safe checkpointing with `--resume`, and `--non-interactive` mode for agents/CI. Blame-aware diff scoping, 14-pattern AI slop detection (hallucinated imports, fake error handling, ghost type assertions, mock-shaped fallbacks, etc.), framework-specific IDOR for Next.js / Express / Fastify / Django / Rails / Go, WCAG 2.2 + dynamic ARIA state detection, performance heuristics, severity-ranked findings with release verdict, and accepted-risk expiry enforcement. Includes a `code-reviewer` agent for proactive autonomous review. v5.0: finding IDs shortened to `CR-NNN` (config/state paths unchanged); the hallucinated-imports validator is now wired into the automated-checks phase (offline, lockfile-verified, runs even in --local-only); history comparison matches findings across runs by fingerprint (category+file+title) instead of per-run IDs, making "show new findings only" trustworthy; the never-implemented `--engine claude|codex|both` flag removed in favor of the real `--adversarial-model <name>` cross-model challenge pass; reports save to `.radcr/history/` only (no loose root-level report file). Backed by `check-hallucinated-imports.py` — a pure-stdlib Python 3.8+ script that parses 9 lockfile formats (package-lock.json, yarn.lock, pnpm-lock.yaml, package.json deps, requirements.txt, pyproject.toml, Pipfile.lock, poetry.lock, uv.lock), extracts imports via Python `ast` + JS/TS regex, and flags packages not declared in any lockfile (slopsquatting risk). Runs standalone or in the orchestrator's Step 5g.
A repo manager for vibe coders — keeps a project's docs minimal, consistent, and honest so coding agents don't get confused or misled by contradictory information. It is the 'manager'; your coding agent is the 'employee.' Four skills, two of them deliberately lean: - `/startup` — orient at the start of a session: read the four active docs + git state, run the two cheap mechanical scans (loose docs, stale docs), surface where you are + what's next + whether the docs are trustworthy. Read-only; recommends `/repo-init` on a fresh repo or `/repo-align` when the scans show drift. - `/wrapup` — leave a clean handoff for a new chat or a post-compaction continuation. Overwrites `docs/handoff.md` from git evidence (not chat memory), then reconciles the active core docs with the session — applying scoped updates to the docs it owns (`docs/plan.md`, AGENTS.md operational sections) on your OK, and drafting exact edits to stale user-owned docs (prd/design/decisions) applied only on per-edit confirmation. Ends with a one-line hygiene pulse. No status/roadmap files, no auto-commit, never runs tests. - `/repo-init` — first-run setup: scaffold the compact doc model (core docs, thin agent shims, minimal folders) on a new or nearly empty repo. Creates only what's missing; never invents product content; never overwrites user-authored files without confirmation. - `/repo-align` — the opt-in deep clean: find drift (contradictions, redundancy, stale/loose/misplaced docs, broken read paths) and propose fixes interactively. Proposes — never auto-acts; moves tracked files with `git mv` to preserve history. Plus an ambient hook layer (Claude Code-only, silent in repos that don't use the doc model, never blocking, says nothing on green): SessionStart injects a one-line doc-health note when something is stale or loose; PreCompact preserves the handoff's raw material (validation results, files changed, next action) through compaction; Stop reminds about wrapup at most once per session when real work is uncommitted and the handoff isn't fresh. The doc model is a tiny, declared, defended core — `AGENTS.md`, `docs/prd.md`, `docs/plan.md`, `docs/handoff.md` (prd/plan/handoff carry an `**Updated:**` freshness stamp) — plus conditional `docs/design.md`, a closed `docs/reference/` catalog, and `docs/archive/` for history. The boundary that matters: `docs/plan.md` owns the durable roadmap/scope/gates/stop-conditions; `docs/handoff.md` owns only the short resume snapshot for the next chat. The plugin authors `AGENTS.md` operational sections, the `CLAUDE.md`/`GEMINI.md` shims, and `docs/handoff.md`; durable changes (prd, design, decision-log) are drafted as exact edits and applied only on your explicit per-edit confirmation. Five pure-stdlib validators: the cheap pair (`repo-scan`, `doc-freshness`) runs every session; the deep trio (`doc-contradiction`, `doc-redundancy`, `audit-user-content`) runs in `repo-align`. Replaces rad-session; Claude-side counterpart to the Codex rad-repo-manager skills. Pairs with rad-planner (which owns `docs/plan.md` content and can birth `docs/prd.md` from its discovery interview; wrapup recommends `/rad-planner:replan` when plan divergence is structural rather than restructuring it itself); works standalone.
A council of cognitive-framework advisors that debates any decision — repo plans, website designs, product/codebase critiques, marketing plans, anything — then votes and returns one ranked, confidence-rated recommendation with dissent preserved and a single concrete next step. Diversity comes from incompatible *reasoning lenses* (The Contrarian, First Principles, The Vulcan, The Metric, The Storyteller, The Outsider, The Executor, The Orator, The Expansionist, The Growth Catalyst), not personas — research shows cognitive frameworks beat roleplay, and that perspective diversity (not debate depth) is the dominant driver of quality. One skill, `convene`, with two modes: `standard` (independent drafts → one blind peer-review round + dot-vote → rigor-weighted synthesis) and `quick` (parallel critics → synthesis, no review round). A Blue Hat orchestrator auto-selects 3–5 seats for any topic by engineering natural tension between opposing lenses (hard cap 5). Synthesis weights by empirical rigor and logical consistency — never headcount — preserves genuine clashes, rates confidence 1–10, and commits to exactly one next step (disagree-and-commit). Guardrails are baked in against the documented failure modes of multi-agent debate: conformity drift (independent generation), sycophancy (framework constraints, not personas), false consensus (preserved dissent), and runaway cost (hard agent/round caps + effort scaling). Claude-only — no external API keys. Output is one self-contained markdown report, delivered where you choose, never auto-committed. Pairs with rad-brainstormer (diverge → converge) and rad-planner (decide → sequence); recommends rad-code-review for deep code passes rather than duplicating it.
npx claudepluginhub radorigin-llc/rad-claude-skills --plugin rad-plannerComprehensive skill pack with 66 specialized skills for full-stack developers: 12 language experts (Python, TypeScript, Go, Rust, C++, Swift, Kotlin, C#, PHP, Java, SQL, JavaScript), 10 backend frameworks, 6 frontend/mobile, plus infrastructure, DevOps, security, and testing. Features progressive disclosure architecture for 50% faster loading.
Develop, test, build, and deploy Godot 4.x games with Claude Code. Includes GdUnit4 testing, web/desktop exports, CI/CD pipelines, and deployment to Vercel/GitHub Pages/itch.io.
Comprehensive feature development workflow with specialized agents for codebase exploration, architecture design, and quality review
Upstash Context7 MCP server for up-to-date documentation lookup. Pull version-specific documentation and code examples directly from source repositories into your LLM context.
Comprehensive PR review agents specializing in comments, tests, error handling, type design, code quality, and code simplification
A growing collection of Claude-compatible academic workflow bundles. Covers scientific figures, manuscript writing and polishing, reviewer assessment, citation retrieval, data availability, paper reading, literature search, response letters, paper-to-PPTX conversion, and evidence-grounded Chinese invention patent drafting. Rules are organized as reusable skill folders with explicit workflows and quality checks.