rad-claude-skills

A council of cognitive-framework advisors that debates any decision — repo plans, website/UX designs, product or codebase critiques, marketing plans, strategy choices — 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 frameworks beat roleplay and that perspective diversity, not debate depth, drives quality. One `convene` skill with two modes: standard (independent drafts → one blind peer-review round + dot-vote → rigor-weighted synthesis) and quick (parallel critics → synthesis). A Blue Hat orchestrator auto-selects 3–5 seats for any topic by engineering natural tension between opposing lenses (hard cap 5, scaled to stakes). 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). Two agents: `council-advisor` (parametrized seat, JSON-first) and `council-chair` (fresh-context synthesizer). 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.

The specialist lanes and memory that the built-in /code-review doesn't have. Invokes the built-in engine for general bug-finding (quick/standard/deep map to its effort levels), then adds what it lacks: a mechanical hallucinated-imports validator (lockfile-verified across Python/JS/TS/Rust/Go, with a vendored denylist of documented malicious typosquat names and 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 refactors, XSS/log-injection sink focus — every pattern sourced and labeled mechanical-vs-judgment); framework IDOR heuristics (Next.js server actions incl. the middleware-is-not-a-boundary anti-pattern, Express/Fastify, Django, Rails, Go); a Supabase/Firebase BaaS-RLS lane with a reachability gate and do-NOT-flag list; and deterministic findings memory — findings-index.py computes fingerprints and assigns stable CR-NNN IDs across runs, so reports show new/recurring/resolved mechanically, never from model memory. --security-deep runs a 4-phase launch-readiness pass (trust boundaries → data-exposure surface → authorization model → secrets) under a no-false-assurance contract: it never emits a "safe to launch" verdict, reports verified-vs-could-not-verify, and recommends a human pen-test. --verify-model runs the lane pass on a different model tier for a cross-tier second opinion. Fix application touches the working tree only — this plugin never commits. Scope is diff/branch/PR only; whole-repo wants /code-review ultra. Deep accessibility belongs to rad-a11y; over-engineering hunts to ponytail-review.

Comprehensive MV3 Chrome extension development standards — WXT framework architecture, MV3 security, permission minimization, typed messaging, storage patterns, service worker lifecycle, React UI, testing, and Chrome Web Store troubleshooting.

Digital accessibility toolkit for WCAG 2.2 AA compliance — semantic HTML, ARIA authoring practices, keyboard navigation, focus management, color contrast, motion/animation, form accessibility, SVG accessibility, and automated testing with axe-core.

End-to-end Coolify self-hosted PaaS management — deployments, databases, security, CI/CD, troubleshooting, observability, multi-server infrastructure, live MCP-backed actions (36 tools), status dashboard, and auto-linting of Dockerfile/compose edits. Coolify v4 self-hosted.

End-to-end 1Password CLI (op) coverage — secret references (op://...), `op inject`/`op run`/`op read` for keeping secrets out of code and shell history, item CRUD with assignment statements and JSON templates, vault and user provisioning with granular permissions, SSH key generation and use, third-party CLI auth via `op plugin run`, and service-account / Connect-server patterns for CI/CD and headless servers. 1 router skill, 6 topical sub-skills, 4 slash commands. Cross-checked against op v2.34.0 --help.

The brainstormer that doesn't anchor you. Most AI brainstorming dumps fifteen ideas at you immediately — and research on human–AI ideation shows you then anchor on them, producing fewer, less varied, less original ideas of your own. rad-brainstormer draws out YOUR thinking first, every time, then builds on it with proven facilitation methods under enforced divergent/convergent discipline (idea generation and evaluation are never mixed). It brainstorms anything — software, business strategy, content, travel, creative projects, life decisions — not just code. Four skills (the standalone technique skills are modes of the session): - `brainstorm-session` — the facilitated session, at two tiers: a quick pass (one technique, top-3 ideas + recommendation, a few turns, zero subagents — the default for small, bounded topics) or the full session (anti-anchoring first, divergent → convergent, live domain research when useful). A mode dial (facilitator / partner / generator) makes who-generates a user choice. Techniques selectable by name: scamper, six-hats, reverse, hmw, starburst, unblock. - `idea-evaluation` — you already have the ideas; structured prioritization (Impact/Effort, Assumption Mapping, Pre-Mortem, JTBD, weighted scoring), with a hard rule that the user scores before the AI does. - `five-whys` — root-cause analysis (a different job than ideation, kept separate). - `design-sprint` — post-decision: chosen software approach → reviewable spec → hand-off to /rad-planner:plan; rad-planner v7+ pre-fills its discovery interview from the spec. Three agents: domain-researcher (live web research woven into the questions, not dumped as a report — offered just-in-time, never upfront), idea-challenger (pre-mortem stress-test of top candidates), spec-reviewer (completeness review — inline self-review first, then at most one dispatch, more only on request). Output is one self-contained markdown file and the skill asks where to deliver it: a personal folder (default for non-project topics; surfaced for download on Desktop/Cowork/claude.ai), into the current project as an explicitly transient doc (consumed by the planner, archived after — never docs/design.md, which is your brand/UI design direction), or no file at all. Never auto-committed. Pairs with rad-planner (ideation → design → plan); works standalone on any topic.

Honest codebase-scoped SEO + AEO tooling: site audits, AI-extractability content linting, keyword ideation, competitor observation, link-building playbooks, schema generation, technical SEO, and E-E-A-T — with every measurement gap declared (no fabricated CWV numbers, keyword volumes, backlink counts, or AI citation rates; Path B MCP unlocks documented in references/CAPABILITIES.md). Four pure-stdlib Python validators: audit-ai-access.py, validate-jsonld.py, audit-meta-tags.py, check-broken-links.py. v2.2: the AI-crawl-access release. New audit-ai-access.py — per-AI-bot robots.txt matrix classed training (GPTBot, ClaudeBot, Google-Extended, CCBot…) vs citation (OAI-SearchBot, ChatGPT-User, Claude-SearchBot/User, PerplexityBot/User, Bingbot, Googlebot), llms.txt existence/format check (recommended per Lighthouse Agentic Browsing, honestly framed as a non-ranking factor), Content-Signal/RSL/noai detection, JS-dependence heuristic (no AI crawler executes JS), optional CDN-block UA probe (Cloudflare default-blocks AI crawlers since July 2025). aeo-optimizer gained a Phase 0 crawl-access gate; technical-seo gained the AI-crawler matrix. Schema deprecation pass (FAQ rich results retired May 2026, HowTo 2023 — now framed as AI-parsing aids). validate-jsonld 1.1.0 genuinely handles framework JSON-LD (dangerouslySetInnerHTML / set:html / template literals; dynamic blocks get honest dynamic_jsonld findings instead of silent skips). De-versioned model references.

Production-grade prompt engineering toolkit — systematic tool-specific routing across 30+ AI platforms (incl. Claude Code and OpenAI Codex/AGENTS.md), loop & goal engineering (loop prompts, /goal and Goal Mode conditions, long-horizon scaffolds, anti-reward-hacking linting), anti-pattern diagnostics, prompt decompilation, autonomous debugging, and context engineering for agentic systems.

Active PARA system management — weekly review automation, folder structure auditing, Progressive Summarization, Intermediate Packet assembly, Hemingway Bridge session handoffs, and 12 Favorite Problems workshop.

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. Pre-fills from the repo AND from dated spec docs (docs/*-spec.md, docs/*-design.md) — a brainstorm or design spec gets confirmed ("the spec says X — still true?"), never re-asked. - One vocabulary, the naming ladder: Goal (the end state, in the PRD) → Release (Now / Next / Later horizons) → Milestone (M1…) → Task (T1…). No phases, sprints, epics, slices, or stages as units of work. The PRD speaks Goal/Release; plan.md speaks Milestone/Task. The repo's AGENTS.md doc-model block is authoritative when present; these defaults match it. - The release ladder in practice: every plan anchors to your end goal via the 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, technical terms glossed on first use) for you; six-field task blocks (objective, files, dependencies, done-when, validation, rollback) for the coding agent. - The seed packet: /plan ends by routing planning's structured leftovers onto the repo's doc shelf — stack choice + why appended to docs/decisions.md, cut features and stray ideas appended to docs/ideas.md, an AGENTS.md stack block proposed (owner applies), architecture/api docs seeded only when their triggers fire. Never creates docs for "Later" work, status/roadmap files, or empty scaffolds. - 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). Gatekeeping follows challenge-once-then-commit: one honest assessment, then full execution on your confirmation, logged as a decision. Four skills — two doors in, one maintained plan: - `/plan` — greenfield or a clear next effort: the six-step conversation → `docs/plan.md` + the seed packet. On a bare repo (no AGENTS.md, no docs/) it recommends /rad-repo-manager:repo-init first and degrades gracefully without it. - `/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. Runs after /rad-repo-manager:adopt when structure is the mess — adopt is structure archaeology, rescue is intent archaeology. Assesses and plans; never fixes, runs, or deletes code. - `/replan` — the single deliberate direction-change moment: marks shipped work from git + handoff (moved to a `## Shipped` section — history preserved, never deleted), gives every parked idea in docs/ideas.md a fair hearing (pull in / keep parked / reject with a recorded why), 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. Changes to docs it doesn't own 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 owns the doc model the planner conforms to, and maintains plan.md status and PRD freshness between plans); works standalone. Two agents: `stack-advisor`, `risk-assessor`.

Explain a project to humans, honestly — without overpromising or inventing features that aren't in the repo. Five skills generate audience-targeted communications from your project's actual artifacts: `narrate-project` (plain-English description, audience-adaptive), `elevator-pitch` (~150 words / ~30 seconds spoken), `draft-pitch` (one-pager for funding, grants, partnerships), `explain-document` (interpret a specific repo file — "what does this commit me to?", "where could this go wrong?"), and `ground-readme` (generate or audit a README so it stays grounded in source). Two pure-stdlib Python validators check every output: `check-grounding.py` traces each substantive claim back to repo source, and `check-overpromise.py` flags superlatives, marketing fluff, and production-readiness assertions without evidence. Works on any repo — no rad-planner dependency. Reads `docs/` if present, falls back to README + project manifest + source structure when absent. The plugin's own README passes its own validators.

A repo manager for vibe coders — a closed doc system where every kind of information has exactly one home, every home has exactly one update trigger, and nothing depends on anyone remembering anything. It is the 'manager'; your coding agent is the 'employee.' The model (references/shelf-spec.md, the single source): a five-layer context stack — L0 `AGENTS.md` (≤40 lines: identity, stack, ≤7 hard rules, the doc-model block) + L1 `docs/handoff.md` (≤60 lines: state + a 'Deferred — do not re-raise' ledger), both injected into every session by hook; L2 `docs/decisions.md` (append-only settled decisions); L3 prd/plan (the planner's); L4 `docs/archive/`. Reference docs live on a closed shelf (decisions, ideas, lessons, design, architecture, api), each created only when its trigger fires — never scaffolded. One vocabulary (Goal → Release → Milestone → Task; phase/slice/sprint/epic/stage banned), one writer per file, and an interaction contract: hard-gate only the irreversible, challenge once then commit, ideas append to docs/ideas.md and block nothing. Six skills: - `/startup` — read-only orientation with a trust report: one line per managed doc, measured in commits-behind (handoff 0–3 green / 4–10 yellow / >10 red), ending with the next task from the handoff. - `/wrapup` — quick by default (<1 min): overwrite docs/handoff.md from git evidence, carry the Deferred ledger forward, ask two questions (decisions settled? → append decisions.md; lessons? → append lessons.md). `--full` adds the session-scoped reconcile pass. No auto-commit. - `/ship` — the close-out chain: mechanical scans → quick wrapup → conventional commit → push origin/main → deploy-verify (only when AGENTS.md declares a `deploy:` target; polls the Coolify MCP when available, degrades to 'verify manually' when not) → stray branch/worktree sweep → one-line report. Invoking /ship IS the commit+push authorization. First ship runs the fit-out: detect repo traits (deploy target, API routes, UI-heavy, TypeScript, CMS, >1 moving part), propose the matching equipment as a menu, install what's approved. - `/repo-init` — greenfield container only: AGENTS.md skeleton with the stamped doc-model block, CLAUDE.md `@AGENTS.md` shim, docs/ + docs/archive/, handoff stub. No shelf docs (their triggers haven't fired); ends by recommending /rad-planner:plan. - `/adopt` — brownfield archaeology, never code changes: git history + docs + code read; L0–L2 drafted from evidence (build/test commands verified by running them); every existing doc triaged onto the shelf (keep/merge/archive via git mv, each move proposed); 5–10 questions only for what evidence can't answer; dormant repos stamped; hands plan reconstruction to /rad-planner:rescue. - `/repo-align` — the deep pass (every ~25 commits or on red trust): doc router (reads off-shelf files and proposes where their content belongs), vocabulary lint, api.md route-diff, on-request rules audit of AGENTS.md (promote to hook / keep in the 7 slots / demote), L0/L1 size budgets, plus the classic contradiction/redundancy/authority checks. Proposes everything; git mv preserves history. Hooks v2 (Claude Code-only, silent in repos without the doc model, never blocking): SessionStart injects an identity banner (repo purpose from the parent folder's CLAUDE.md glossary when one exists — the wrong-repo guard), the handoff content, and a trust summary; Stop nudges once per session when the handoff drifts >3 commits behind or real work sits uncommitted (suppressed by the Deferred ledger); PreCompact asks for a quick handoff refresh — or verbatim preservation of its raw material — before context loss. Six pure-stdlib validators (repo-scan, doc-freshness with the trust block, vocab-lint, doc-contradiction, doc-redundancy, audit-user-content). Pairs with rad-planner v7 (which reads the repo's doc-model block, writes prd/plan in the shelf's headings and vocabulary, and seeds decisions/ideas at /plan) and rad-brainstormer v4 (transient dated specs, rejected ideas routed to ideas.md); works standalone.