awesome-claude-code-plugins

Run structured AI meetings for plans, product ideas, technical designs, business decisions, feature proposals, and strategy choices. Use when the user wants an AI meeting, AI roundtable, multi-agent discussion, debate, proposal review, plan review, decision review, or wants Codex, Claude Code, and other CLI agents to analyze a proposal across multiple expert roles, challenge assumptions, preserve per-agent sessions, and produce a final decision report with provenance. 也适用于中文场景：方案评审、多 Agent 讨论、技术路线评审、商业决策评审。

Self-learning system that captures corrections during sessions and reminds users to run /reflect to update CLAUDE.md. Use when discussing learnings, corrections, or when the user mentions remembering something for future sessions.

Write up a coding session for a non-technical stakeholder — the context, what was built, and the engineering reasoning behind it — the way a senior engineer briefs a product manager who does not read code. Use ONLY when explicitly invoked, either through the /dev-report slash command or one of its localized aliases (/개발보고 and similar), or when the user directly asks for a stakeholder-facing write-up of the session ("write today up for my PM", "explain this session for a non-developer", "개발 보고서 써줘"). Do NOT trigger on an ordinary "what did you just do?" — that wants a short plain answer, not a report.

Verifies and formats APA 7 Korean academic citations across 14 source types, augments DOIs via CrossRef, and applies CopyKiller 99-rule avoidance. Use when the user requests APA 인용 검증, 참고문헌 양식 확인, CrossRef DOI 보강, 박사 논문 인용, or CopyKiller 회피.

Use this skill when the user asks for a tarot reading, I Ching (Yijing) hexagram cast, or Chinese Xiao Liu Ren (小六壬) divination. Calls audited local Python tools that produce deterministic JSON output; the model never invents the result, it only interprets the JSON.

Scan SEC Form 4 insider trades and 13F ownership moves for a ticker or a watchlist using the AlphaAI MCP. Use when the user asks about "insider buying", "insider selling", "Form 4 activity", "who's buying <ticker>", "institutional ownership changes", or wants an insider-activity sweep.

List, add, or remove the user's ticker news-alert subscriptions through the AlphaAI MCP. Use when the user asks to "alert me on <ticker>", "subscribe me to <ticker> earnings news", "what alerts do I have?", "stop alerts for <ticker>", or to manage their AlphaAI alert inventory. Requires a paid (Basic/Pro) AlphaAI plan.

Summarize what's moving in the market right now using the AlphaAI MCP. Use when the user asks "what's moving?", "what's the big story today?", "anything breaking?", "market pulse", or wants a fast read on the current tape rather than one specific ticker.

Compare two tickers and surface the cross-read between them using the AlphaAI MCP. Use when the user asks to "compare X and Y", "NVDA vs AMD", "what does <peer>'s news mean for <ticker>", or wants the read-across between two related names (competitors, supplier/customer, same theme).

Produce a situational brief on a single stock/ticker — its recent high-relevance news, insider activity, and what to watch next — using the AlphaAI MCP. Use when the user asks to "brief me on <ticker>", "what's going on with <company>", "catch me up on NVDA", or wants a quick read on one name.

Bootstrap a new FastAPI backend with async SQLAlchemy 2.0, asyncpg, Alembic, Pydantic v2, and no deprecated APIs. Use when the user wants to start, scaffold, or set up a new FastAPI service, a Python REST API, an async backend, or asks to "create a new fastapi app" or "new python backend". Handles JWT auth, layered app structure, Docker + Postgres, and Vercel or container deploy.

Bootstrap a new Flutter mobile app with clean architecture, Riverpod, FVM-pinned SDK, current packages, and no deprecated APIs. Use when the user wants to start, scaffold, or set up a new Flutter app, a cross-platform mobile app, an Android or iOS app in Dart, or asks to "create a new flutter app". Handles BYOK LLM apps, backend-backed apps, Play Store release setup, and clean-architecture feature structure.

Bootstrap a new Next.js (App Router, TypeScript) web app with current packages and no deprecated APIs. Use when the user wants to start, scaffold, or set up a new Next.js project, a React web app, a SaaS or dashboard or landing page on Next.js, or asks to "create a new nextjs app". Handles private, open-source, and private-plus-open-source variants, Prisma and Postgres, next-auth, Tailwind, and shadcn or Mantine.

Adaptive vault reader skill. Receives a natural language question, searches the vault first (Glob/Grep, entity reads, wikilink traversal), then self-assesses whether more context is needed. Escalates to /graphify for graph-level understanding or to /bedrock:teach for remote content ingestion only when the vault alone is insufficient. Answers simple questions with zero graphify calls. Use when: "bedrock ask", "bedrock-ask", "/bedrock:ask", any question about the vault, "what do we know about", "who owns", "what's the status of", "tell me about", "how does it work", or any Second Brain query.

Vault alignment engine. Detects and fixes 5 types of structural misalignments: broken backlinks, concept fragmentation, entity miscategorization, duplicated entities, and misnamed entities. Delegates all writes to /bedrock:preserve. Supports interactive mode (user confirmation) and cron mode (autonomous mechanical fixes + queued semantic proposals). Use when: "bedrock compress", "bedrock-compress", "align vault", "fix backlinks", "fix misalignments", "/bedrock:compress".

Internal fetcher module for Confluence pages. Fetches content via Atlassian MCP (preferred), REST API with Basic Auth (fallback), or browser DOM extraction via Claude in Chrome (last resort) and returns Markdown. Used by /bedrock:teach and /bedrock:sync — not intended for direct user invocation.

Internal fetcher module for Google Docs and Sheets. Fetches content via MCP (preferred, when available), Google API with bearer token or public URL export (fallback), or browser DOM extraction via Claude in Chrome (last resort) and returns Markdown. Used by /bedrock:teach and /bedrock:sync — not intended for direct user invocation.

Read-only vault health diagnostic. Generates a report without modifying any files. Checks: graphify-out integrity, setup verification, orphan entities, dangling content, old content (>15 days). Safe to run at any frequency. Use when: "bedrock healthcheck", "bedrock-healthcheck", "vault health", "check vault", "vault status", "/bedrock:healthcheck".

Single write point for the vault. Centralizes entity detection, textual matching, entity creation/update, and bidirectional linking. Accepts structured input (list of entities), free-form input (text, meeting notes, session context), or graphify output (graph.json + obsidian markdown from /graphify pipeline). Use when: "bedrock preserve", "bedrock-preserve", "save to vault", "record in vault", "/bedrock:preserve", or when another skill (e.g., /bedrock:teach) needs to persist entities in the vault.

Initialize any folder as a Bedrock-powered Obsidian vault. Creates entity directories, copies templates, configures language and domain taxonomy, scaffolds connected example entities, and checks dependencies. Use when: "bedrock setup", "bedrock-setup", "/bedrock:setup", "initialize vault", "setup vault", "create vault", "bootstrap vault", or when a user wants to start a new Second Brain with Bedrock.

Re-synchronizes the vault with external sources. In default mode, scans the `sources` field of all entities, deduplicates URLs, fetches updated content from each source (Confluence, GDocs, GitHub, Markdown), performs incremental diff and delegates writing to /bedrock:preserve. With --people, scans actor repositories via GitHub API and identifies active contributors. With --github, detects relevant activity in repositories and correlates PRs with topics/projects via LLM semantic matching. Use when: "bedrock sync", "bedrock-sync", "/bedrock:sync", "synchronize", "update sources", "sync people", "sync github".

Teaches the Second Brain to recognize a new external data source. Fetches content from Confluence, Google Docs, GitHub repositories, remote URLs, or any local file format supported by docling (DOCX, PPTX, XLSX, PDF, HTML, EPUB, images, Markdown, CSV, and more), converts non-markdown formats to markdown via docling, runs the /graphify extraction pipeline, and delegates entity persistence (including the graphify-output merge) to /bedrock:preserve. Use when: "bedrock teach", "bedrock-teach", "teach", "ingest source", "import document", "/bedrock:teach", or when the user provides a Confluence, Google Docs, or GitHub URL, a remote file URL, or a local file path to incorporate into the vault.

Manage registered Bedrock vaults. List all vaults, set a default vault, or remove a vault from the registry. The registry lives in the plugin directory and maps vault names to filesystem paths. Use when: "bedrock vaults", "bedrock-vaults", "/bedrock:vaults", "list vaults", "set default vault", "remove vault", "show vaults", "which vault", "my vaults", or when a user wants to manage their registered vaults.

Adversarial self-review for code that touches a trust boundary. After you write or change code that handles untrusted input, authenticates, authorizes, queries a database, reads files, makes network calls, runs a subprocess, deserializes, or handles secrets or money — switch hats and try to break your own output before calling it done. Think like an attacker: the input that overflows it, the request that skips the auth check, the id that reads someone else's row, the payload that escapes the query. Fix what lands, report what you tried. Supports intensity levels: lite, full (default), ultra. Use whenever the user says "attacker", "red team", "attack this", "break it", "harden", "is this safe/secure", or ships security-sensitive code. This is DEFENSIVE — you attack your OWN code to fix it. Do NOT use to attack systems you don't own, or for non-coding requests.

Match the house style when adding code to an existing codebase. Before you write, read the neighbors — naming, error handling, imports, the repo's idioms, the test style — and make your code read like the file next to it. Reuse the project's own helper, wrapper, or Result-type instead of importing your favorite. New code should be indistinguishable from what's already there. Supports intensity levels: lite, full (default), ultra. Use whenever the user says "chameleon", "match the style", "match the codebase", "fit in", "blend in", "follow the conventions", or adds code to an existing project. Do NOT use on greenfield/empty repos, or to copy a pattern that's actively broken or insecure — flag those instead. Not for non-coding requests.

Anti-premature-"done". Before you claim a non-trivial task is complete, working, or fixed — stop asserting and start demonstrating: run it, execute the test, hit the endpoint, trace the path, and show the real output. "Done" means proven, not believed. If you genuinely can't run it, say exactly what's unverified and how the user checks it — don't smuggle an untested claim behind a checkmark. Supports intensity levels: lite, full (default), ultra. Use whenever the user says "closer", "prove it", "did it actually work", "verify", "are you sure", or when you're about to report success. Do NOT use for trivial one-line edits, or for non-coding requests.

Dependency gatekeeper. Before you add any new package — `npm install`, `pip install`, `go get`, a new import of something not already in the lockfile — stop at the door and make it earn entry. Ask whether the stdlib, the runtime/platform, or a dep already installed does the job, and whether a few lines would too. A dependency is a permanent cost: maintenance, supply chain, bundle weight, breakage on someone else's schedule. Weigh size, last release, and transitive deps — not just "does it work." Supports intensity levels: lite, full (default), ultra. Use whenever the user says "doorman", "do we need this dep", "vet this package", "can we avoid the dependency", or reaches for a new install. Do NOT use for deps the task explicitly requires, or for non-coding requests.

Reviewable git hygiene for work you're about to commit or open a PR for. Before the commit, split the change into small self-contained commits — one logical change each — and write messages that explain WHY, not just what, so the person debugging this at 3am (usually you) can follow the story. Structure the diff so a reviewer reads it top to bottom and understands. Supports intensity levels: lite, full (default), ultra. Use whenever the user says "explainer", "commit this", "make a PR", "clean up the history", "write the commit message", or ships non-trivial work to review. Do NOT use for trivial one-line fixes, WIP the user asked to keep messy, or non-commit requests.

Anti-hallucination discipline for any code that names an external symbol you aren't certain exists — a library function, method, config key, package version, CLI flag, env var, or endpoint. Before you call it, cite it, or import it, confirm it's real: grep the codebase, read the installed package's actual signature, check the lockfile. If you can't verify, write "unverified" instead of asserting. When memory and the repo disagree, the repo wins. Supports intensity levels: lite, full (default), ultra. Use whenever the user says "fact-check", "verify this exists", "did you make that up", "check the API", "no hallucinations", or you're wiring up an unfamiliar library or codebase. Do NOT use for language keywords or stdlib you're certain of, or trivial code with no external symbols.

Chesterton's Fence for code you're about to delete or refactor. Before you rip out a weird retry, a seemingly dead branch, an ugly workaround, or a "redundant" check whose purpose isn't obvious — find out why it exists first. git blame it, find the callers, read the linked issue/PR/commit. If you can't explain why the code is there, you're not ready to remove it; if it guards a real edge case, keep it and write down why. Supports intensity levels: lite, full (default), ultra. Use whenever the user says "historian", "clean this up", "remove dead code", "why is this here", "simplify/refactor this", "delete the workaround", or moves to strip code they don't understand. Do NOT use for code you wrote this session, code you can prove is dead, or non-coding requests.

Anti-guessing discipline for ambiguous requests. Before building, spot the assumptions that FORK the implementation — the ones where guessing wrong means rebuilding — and ask only the questions whose answers change what you build (2–4 max). When a request is under-specified in a way that changes the design, ask first; when it's clear or the ambiguity is a trivial default, pick it, note it, and move. If you must proceed unanswered, state your assumptions and build the reversible version. Supports intensity levels: lite, full (default), ultra. Use whenever the user says "interrogator", "ask me", "clarify", "what do you need to know", "requirements", or hands you a vague feature. Do NOT use for well-scoped tasks, matters of taste you can default, or non-coding requests.

Anti-sycophancy for build requests that encode a wrong assumption. Before you touch the keyboard, separate what the user ASKED for from what they're trying to achieve — and if the request bakes in a mistake (premature optimization, complexity bigger than the problem, cargo-culted pattern, solving the wrong problem), say so first, with a reason and a concrete alternative. Then build what they decide. Supports intensity levels: lite, full (default), ultra. Use whenever the user says "skeptic", "push back", "challenge this", "is this the right call", "sanity-check this", or hands you a request that smells off. This is a truth-teller, not a contrarian — you disagree only when you'd bet on it. Do NOT use for well-scoped requests, matters of taste, after the user says "just do it", or for non-coding requests.

Anti-thrashing circuit-breaker. After two failed attempts at the same problem with the same approach, STOP editing — the theory of the cause is wrong, not the patch. Re-examine assumptions, add instrumentation, and trace from the source before touching code again, instead of re-trying variations of the fix that already failed. Supports intensity levels: lite, full (default), ultra. Use whenever you catch yourself looping — re-running a failing test with a tweaked value, re-adding a guard that didn't help, guessing at parameters — or when the user says "stop digging", "you're going in circles", "step back", "stop guessing". Do NOT use on first attempts, on genuinely new sub-problems, or for non-coding requests.

Configure and control the claude-bionify bionic reading plugin. Use when the user asks about bionic reading settings (fixation/strength, boundary, minimum word length, acronyms, URLs, headings), wants to turn the bionic display on, off, or toggle it, asks for the current status, or asks how to use the /claude-bionify commands.

Suggests a cross-model second opinion after substantial or risky code changes. Use when a significant implementation, refactor, security-sensitive change, or uncertain bug fix has just been completed and is about to be committed or shipped. Advisory only — it recommends running /claudex:verdict; it never invokes Codex on its own.

Saves and searches past Claude Code sessions so context, decisions, and code persist across conversations. Use when user says 'remember this', 'save this session', 'recall', 'search past sessions', 'what did we discuss about', or 'find previous work on'. Do NOT use for general file storage, note-taking, or bookmark management.

Use when about to report any nontrivial task as complete — requires closing with a Caveats & status section stating what was verified, what was assumed, and what's unresolved.

Use before any git commit, branch, or pull request — defines the project's conventions for atomic commits, message format, branch naming, and PR hygiene so history stays navigable, bisectable, and safe to ship.

Use before retrying any command, tool, or approach that failed once, and immediately after discovering any OS/shell/tool-specific quirk — checks and updates a stable cross-project quirks file so failed approaches are never silently repeated.

Use during root-cause investigation of any bug in a project that has graphify-out/graph.json — surfaces related code before grepping, flags likely duplicates of existing KNOWN_ISSUES.md entries before filing a new one, and when a match lands on a resolved entry surfaces its recorded fix so a known-good fix can be reused. No-op in any project without a built graph.