Plugins

Utility skills — Claude Code guide, NotebookLM, Graphify, awesome lists

Standalone developer utility skills, independent of the SDD workflow

Codex review, media tools, and HTML presentations

Daily agent tools: artifact creation, advisor review, browser automation, TUI automation, subagent orchestration, and Codex model routing.

Tool operation skills for Firecrawl web search, scraping, research, and content extraction.

tools-registry Script-Runner (stdio)

General purpose CLI tools: fd, ripgrep, jq, yq, shell scripting, ImageMagick, Mermaid diagrams, and universal dependency installation

Aggregates your MCP servers and exposes three tools instead of hundreds, with a live token-savings receipt.

Semantic folder index for codebase navigation. Creates index.toon files with summaries ordered by priority. "Oh, I see you've discovered my meticulously organized archive."

Six portable skills for Socratic inquiry, root-cause analysis, critical review, systems thinking, first-principles analysis, and Feynman clarification.

Provider-agnostic Claude Code statusline plugin (ToPGauge) for token-plan usage and account balance. Picks the provider from ANTHROPIC_BASE_URL (currently MiniMax + DeepSeek); hides itself otherwise. Ships :install, :uninstall, :clean, and :clean-cache slash commands.

69-skill Topia Nexus for Claude Code — TDD rails, readiness/guardian/completion-gate hooks, Maestro routing, optional agora-code neural memory

Plugin from toraco/claude-skills

Benchmark a Hugging Face model on an Intel GPU through pure PyTorch + Transformers, **single-process, no HTTP server**. Measures generate() throughput in tokens/sec, time-to-first-token, decode-step latency, and peak XPU memory. Also covers diffusion and encoder-only models via `references/non-llm-snippets.md`. Use after **model-can-it-fit** to validate predicted memory against `torch.xpu.max_memory_allocated()`.

Profile a Hugging Face model on Intel GPU at the **PyTorch level** with `torch.profiler` and Kineto. Captures CPU + XPU timeline, exports Chrome trace, identifies hottest kernels and async-overlap gaps. Use when the user asks why a model is slow, which op is the bottleneck, or where the GPU is idle. Not for profiling inside a running vLLM server (use vllm-xpu-profile) or for SYCL-kernel-level signal beneath the PyTorch op layer (use xpu-profile-unitrace).

Run an arbitrary Hugging Face safetensors model on an Intel GPU using **upstream PyTorch** (>= 2.8) with the built-in `torch.xpu` device. Covers loading from the Hub, picking the right dtype, autocast, multi-GPU with accelerate's `device_map`, and the CUDA -> XPU code translation a user has to do once. Use for the Transformers / Accelerate / Diffusers path. Not for OpenAI-compatible serving (use vllm-xpu-run); explicitly not via intel-extension-for-pytorch (ipex) or ipex-llm — those paths are end-of-life and upstream PyTorch supersedes them.

Skills for searching and downloading torrents from nyaa.si (anime), YTS (movies, ytz.mx), and managing downloads via qBittorrent.

토스증권 Open API로 국내·미국 주식 시세/종목/환율/장운영 조회와 계좌·보유주식·주문을 다루는 플러그인 (tossinvest CLI 기반)

Cross-session, cross-CLI memory for AI coding assistants. Mines transcripts from 10 supported CLI clients. Surfaces operator identity / decisions / bans / corrections / goals / voice via 26 MCP tools, 6 hooks (SessionStart signpost + SessionStart compact-restore + UserPromptSubmit retrieval + Stop/PostCompact re-index + PreCompact continuity-seed), 15 slash commands, and 3 skills. gte-modernbert hybrid recall; worktree-aware project scoping; post-compaction coding-continuity packet. Optional local-LLM refinement ([llm] extra, ollama, off by default). The operator becomes the source of truth; the model stops re-asking what they already told it.

Mobile engineer — native iOS/Android, cross-platform, app stores, mobile performance

from satoruhiga/claude-touchdesigner

Tower compute platform — run and deploy Python apps, pipelines, and AI agents

from towns-protocol/skills

Marketplace discipline enforcement — single `validate-plugin` skill + `tp-roster-auditor` agent + `scripts/audit.py` CI guard. Audits any Claude Code marketplace for the 5-rule discipline set: agent roster cap (default 6 keepers + 1 read-only-tools exception), spawn-lens contract (`lens:`/`scope:`/`question:` within 200 chars), fork-skill rationale (every `context: fork` skill has `references/fork-rationale.md`), description quality (≤1536 chars, verb-led first 200, CONTRAST vs adjacent), and catalog discipline (`plugin.json` version matches marketplace + description mentions roster). Use when user says 'audit my marketplace', 'check discipline', 'roster check', 'validate before commit', 'discipline-check'. NOT for: marketplace schema validation (use `claude plugin validate`); NOT for: implementation work (use the relevant domain skill).

First Principles Framework — structured reasoning in an isolated forked context with hypothesis generation, evidence validation, and auditable decision records. PROPOSE / MAINTAIN / QUERY modes. Verification stages spawn `tp-critic` with FPF-specific lenses.

Git workflow automation — conventional commits, PR creation, issue analysis, git notes, worktrees, and inline PR review comments. PR reviews fan out `tp-critic` per changed file with the 'review this diff for bug, security, and contract errors' lens.

Principled MCP (Model Context Protocol) expertise hub — a single skill `mcp-expertise` with five modes covering the full MCP server lifecycle: DESIGN (tool decomposition, output contract, JSON-RPC error discipline, capability negotiation, security checklist, naming, Claude-Optimal validation), SCHEMA (JSON Schema 2020-12 authoring, additionalProperties:false discipline, discriminator enums, constraint discipline, description writing, pitfalls catalog, schemars cheatsheet), IMPLEMENT (Rust with rmcp 0.3 + schemars + tokio, transport choice stdio vs Streamable HTTP, stderr-only logging, error mapping via rmcp::ErrorData, testing with MCP Inspector CLI mode; implementation runs inline in the main agent or forked orchestrator), CLIENT (agent as MCP consumer — the four installation paths, JSON-RPC discovery flow, calling pattern, consumer-side debugging, rmcp client SDK for stdio and Streamable HTTP), and QUALITY (8-dimension Claude-Optimal rubric, forked orchestrator spawns 8 parallel `mcp-quality-judge` subagents in isolated contexts — the single domain exemplar of the lens-prompt pattern). The §3 worked example in `mcp-expertise/references/design-decomposition.md` uses a synthetic `git-cli` decomposition. Hub is a pure router; mechanism lives in `references/`. Includes 1 subagent: `mcp-quality-judge` (QUALITY leaf, background, yellow) — the only marketplace subagent that preloads its domain skill via `skills: [mcp-expertise]`.

Principled Rust project skills — single `rust` hub with a `Modes:` directive covering the full Rust lifecycle: SCAFFOLD (lib/bin decision, Cargo.toml template edition 2024, MSRV 1.81, feature flag design, lib+bin code layout, rustdoc, edition migration), WORKSPACE (when to split, virtual workspace template, workspace inheritance, Cargo.lock policy, MSRV coordination, cross-crate patterns, workspace publishing), QUALITY (canonical 6-job CI, clippy + rustfmt policy, cargo-nextest, coverage, supply-chain ladder, dev-experience tooling), RELEASE (Cargo semver, changelog tooling, cargo publish playbook, supply-chain maintenance, feature deprecation), REVIEW (holistic existing-project health audit via 5 parallel tp-critic lenses — source-code health & idioms, dependency hygiene, build & test health, public API surface, supply chain). Each mode dispatches `tp-critic` with Rust-specific lenses (Cargo.toml audit, CI configuration, supply chain, pre-publish, source-code, dependency hygiene, build/test health, public API surface); the inline Rust idiom-polish checklist handles code cleanup.

Structured agent-driven development with multi-judge evaluation — runs a single solution in an isolated forked context with self-critique, and scores it via parallel isolated-context judges. EXECUTE mode (implement + verify) and JUDGE mode (multi-judge debate). One specialist subagent (`sadd-judge` for rubric-based candidate scoring).

Principled security review skills — single `security` hub with a `Modes:` directive covering the pre-production security review lifecycle: SAST (static application security testing for injection, auth bypass, SSRF, deserialization, access control), DEPENDENCY-AUDIT (CVE scanning, lockfile drift, typosquatting, supply-chain integrity), SECRETS-DETECTION (API keys, tokens, credentials, private keys via pattern matching and entropy analysis), COMPLIANCE (OWASP ASVS, GDPR, SOC2, PCI-DSS, HIPAA evidence mapping and gap analysis). All four modes spawn `tp-critic` with a mode-specific lens (OWASP / supply-chain / secrets / compliance).