Recently added

Independent stronger-model second opinion at key moments — stuck debugging or an imminent irreversible action. /fresh-take:consult composes a facts-only brief (no leaning) and dispatches a blind stronger-model consultant with read-only repo access; it returns a Take, Risks, and one Alternative. A UserPromptSubmit reminder hook nudges the command on key-moment phrases. Advice only — it never blocks, gates, or edits anything.

Infrastructure in one plugin: CI/CD ordering, container/image hygiene, Kubernetes limits and probes, deploy strategy with rollback, and secrets handling (devops-practices); Dockerfile and compose discipline (docker-best-practices); and local dev environments generated from evidence — manifests, lockfiles, .env DSNs, CI images — via /devops:init (compose-init). One /devops:review loads the Docker skill when a Dockerfile or compose file is in scope, backed by a PreToolUse guard on workflow files and a devops-engineer worker + devops-reviewer pair. Owns infra-layer observability wiring; defers in-code instrumentation to resilience's observability skill.

See real components before deciding: /design-lab:preview renders 2-3 candidate variants with the project's OWN components on its own dev server (Vite React/Vue/Nuxt or Laravel Blade/Livewire, scratch surface removed at cleanup, strict consent gate, shell-mockup fallback for greenfield); and two MCP servers read component registries from the source, never from memory — a dependency-free local one for Aceternity, shadcn and Magic UI (24h-cached, every answer carrying its source URL, fetch date and stale flag, 3D/particle runtimes flagged) plus ReUI's own hosted server, delivered by install and authenticated by the user's own browser sign-in.

Systematic debugging: root cause before any fix — reproduce first, read the actual error, isolate with hypothesis tests and bisection, one change at a time, verify against the original symptom; escalation rule after three failed fixes. Ships a delegatable debugger agent for handing off the long reproduce-bisect investigation. Includes /debugging:debug.

Relational databases in one plugin: the engine-agnostic sql-best-practices skill (sargable predicates, joins, indexes, NULL logic, transactions, keyset pagination, safe migrations, parameterization), the mariadb-best-practices dialect skill (10.6+ divergences, RETURNING, sequences, system-versioned tables, Galera) that the code-review fan-in loads only when the detected engine is MariaDB, a database-engineer worker that applies schema, migration, indexing and pooling work, and a PreToolUse guard that asks before a destructive statement (DROP/TRUNCATE/unqualified DELETE-UPDATE) lands.

Meta-bundle: the creative-build studio in one install — concept-first creative direction with a tiered motion catalog and WebGL/Three.js effects (craft-layer), plus ui-ux: per-library stack skills (shadcn, ReUI, Aceternity, Astryx, MUI, Tailwind), the WCAG audit, CSS-variable theming with a live colour preview, and the accessibility engineer that applies an audit's fix list. Live component-registry lookups route to the registries' own MCP servers — shadcn's and ReUI's — named in ui-ux's stack skills; this marketplace ships none. Uninstall with /craft-suite:uninstall.

Create unique, animated, informative web apps (CRM, SaaS, landing pages) across React, Tailwind, Vue, Next, Nuxt, and Laravel. /craft-layer:craft runs the studio pipeline end to end — creative direction, design research, asset sourcing with a licence gate, theming and component build via ui-ux, and a tiered motion system (Framer, anime.js, Three.js/R3F, Lottie/Rive, sprites) with reduced-motion and reduced-bundle fallbacks. /craft-layer:sections guides per-section decisions, /craft-layer:audit reviews a shipped tree, and ultra-craft escalates a run with live web research and a red-team of the result. Ships the Three.js/R3F skill (WebGPU-first, TSL, asset pipelines, disposal) behind /craft-layer:craft; Three.js review arrives through /code-review:review. Requires ui-ux, which carries the WCAG audit.

Destructive-command prevention: a PreToolUse hook that classifies every Bash (and MCP shell/SQL) command before it runs — denying irreversible data loss (migrate:fresh, db:wipe, DROP DATABASE, rm -rf /, git clean -fdx, docker compose down -v, terraform destroy, cloud deletes) and prompting on scoped-but-destructive ones (git reset --hard, rm -rf ./dir, kubectl delete pod). Reads through quotes, wrappers and heredocs; skips read-only commands; fail-open. Ships /command-guard:check and a user-owned allow-file the agent cannot edit.

Stack-agnostic code review: correctness bugs, code smells, convention drift on any diff or PR — severity-sorted one-line findings — plus comment discipline: every fact routed to the artifact that cannot lie about it, comments spent only on why-not-the-obvious, external constraints, intentional silence and contract facts (default: no comment; write-time hooks warn, and deny the three strictest patterns plus any whole file over a 0.4:1 comment ceiling, once per file per session; /code-review:comment-review). Defers structure/YAGNI to code-architecture, security depth to security, stack idioms to the per-framework review plugins. Includes /code-review:review, a code-reviewer agent, the code-smells, reuse-hygiene and comment-discipline skills. The fan-in for overlapping review surfaces: loads every installed matching stack skill in one pass.

Engineering process: plan-before-code, YAGNI, SOLID principles applied with judgment, task orchestration, work verification — held at Stop by candor's gate (clause 3, refusing a completion claim when files were edited but nothing ran afterward) when candor is installed; without it the rule is prose — low-cognitive-load code, KISS/DRY simplicity principles. Owns structure at both levels: code (units, interfaces, file placement) and system (service boundaries on data ownership, scaling paths, cache placement, sync vs async integration, domain modeling) via the system-design and domain-modeling skills and the system-architect worker.

Candour as a mechanism, not a pep talk. One blocking Stop gate, five clauses a script can prove: a file:line citation resolving to no file or past its end; a position retracted after bare pushback with no tool call in between; a completion claim after edits with nothing executed since; a task-runner run stopping without its recorded gate pass; a dependency map changed with an untouched lockfile. Flattery, apologies and defensive phrasing are counted by /candor:check and blocked by nothing, on purpose. Plus the terse reply mode (/candor:level lite|full|ultra|off): chat-message brevity as a shape contract — prose-line budgets and a fixed report skeleton, never less work in the turn.

A committed, Obsidian-style codebase map for a project: brain/INDEX.md indexes areas, key files, and notable classes/entrypoints so a fresh Claude session starts oriented. A SessionStart hook injects the compact map (with a staleness hint when it lags HEAD); /brain reads it and /brain index builds/refreshes it. Builds the map only — it never annotates code, and nothing outside brain/ is ever modified.

Solution-approach deliberation before non-trivial implementation: 2-3 structurally different approaches with trade-offs and a kill-trigger, a strategy catalog mapped to the risk each beats, a four-persona blind opinion round for refactor-shaped tasks — plus the merged pre-code disciplines: build-vs-buy checks, S/M/L/XL estimation, rollout planning, design-pattern selection, and /approaches:consult, a blind stronger-model second opinion when a session is stuck or about to do something irreversible (fresh-take merged in). Includes /approaches:compare, /approaches:opinions, /approaches:build-vs-buy, /approaches:size, /approaches:rollout, /approaches:pattern.

APIs in both directions: design your own (resource naming, status-code discipline, pagination/filtering/sorting, versioning, RFC 9457 errors, idempotency, Laravel API Resources, plus a graphql-grpc skill for non-REST surfaces; /api-design:review and spec-first /api-design:scaffold) and consume others' honestly — verify current official API/SDK docs before writing integration code (UserPromptSubmit reminder + /api-design:check, the api-docs-first skill) and keep your own docs true after a change with the docs-upkeep drift scan: README claims, changelog gaps, stale examples, dead links (/api-design:drift).

Meta-bundle: the user-scope baseline — project-agnostic plugins worth enabling once in ~/.claude/settings.json and keeping on everywhere. secret-scanning's write-time secret block, candor's honesty Stop gate, lean's output pricing, terse's chat-brevity contract (inert until you set a level), file-aware skill auto-routing (skill-router), git-workflow discipline, cross-session friction mining (hindsight), and two scouts for what this bundle leaves out (plugin-scout, vercel-skills-scout) — command-guard among them, whose ask tier replaces the host's own permission classifier. Membership is prose, unchecked. /always-on-suite:uninstall removes the bundle and prunes what it installed.

Read-only Modbus map, byte-order, tool-generation, and capture-analysis workflows.

AI coding assistant toolkit - git workflow protection, verification, shipping, research, and development automation

Matt Pocock's agent skills for real engineering: grilling, spec/ticket flows, TDD, code review, domain modelling and more. Plug-and-play, not vibe coding.

Datadog observability guidance via the pup CLI

Autonomous experiment loop — iteratively optimize any metric with git-tracked experiments

Jira work guidance via the official Atlassian twg CLI

Manoo — the hands Claude Code needs to act on your screen. Screenshot, click, type, scroll — so Claude can operate your desktop directly when you ask it to do something itself. Free-tier local prototype: everything runs on this machine, nothing is sent anywhere. By Corporación Jamiel.

NDI's UO-03 AI Employee. Handles the volume work of recruiting — sourcing, CV screening, scheduling and candidate communication — so recruiters spend their time on interviews and offers. Audits the requirement matrix for criteria that act as proxies for a protected characteristic BEFORE any candidate is screened, and demands a written job-related justification rather than banning the phrase: lifting 25kg is lawful for a warehouse role and unlawful for a desk job, and a tool that forbids the words refuses legitimate work and gets switched off. Screens only against audited criteria, with CV evidence behind every state, and never reads an unevidenced criterion as unmet — a decline is unavailable while anything is unknown, and the message step refuses to draft one without a card that recommends it. Routes internal applicants, referrals, accommodation requests and complaints to named humans instead of screening them. Reports who has been waiting in silence, which stage counts cannot show. Never records or cites a protected characteristic. Never sends: every message is a draft a named person releases.

Isolated Claude manager codec fixture. Includes 1 skill.

Pasture skills for Claude Code — the 12-phase protocol delivered as role skills (supervisor, worker, reviewer, architect, epoch) and phase sub-skills, generated from the pasture Go codegen.

Pasture lifecycle hooks for Claude Code — inject beads workflow context on session start and before compaction, and enforce shared-worktree git discipline for worker agents. Installed default-off; enable explicitly.

Pasture agents for Claude Code — the five protocol roles (supervisor, worker, reviewer, architect, epoch) as installable subagents, generated from the pasture Go codegen.

Pasture — a 12-phase protocol for structured multi-agent software development, delivered as Claude Code skills and agents (supervisor, worker, reviewer, architect, epoch + phase sub-skills) generated from the pasture Go codegen. Beads task tracking and vertical-slice TDD implementation.

Local-first design app · 139 skills + 150 DESIGN.md systems · exposes projects/files/preview tools to your coding agent over stdio MCP. Requires the `od` daemon on PATH.

A portable community plugin for validating Open Design plugin import flows.

Edit CapCut and JianYing (剪映) projects from Claude Code — subtitles and SRT/ASS import, timing, speed, volume, keyframes, masks, filters and effects, templates, lint --fix, render previews, and cutting long-form to shorts.

Autonomous, ticket-anchored AI development for GitHub Issues, Linear, and JIRA, built on one idea: stop slop before it goes in, instead of reviewing it out afterwards. Work starts from a ticket, not a prompt. One command drives the whole lifecycle for one ticket or twenty at once, interleaved and unattended: investigate, write failing tests for what the ticket requires (never for what the code already does), prove each one fails for the right reason, attack the plan adversarially, implement without touching the tests, then run four mechanical gates — slop detection, a vacuity check that proves each test would have failed before the branch existed, a complexity gate, and a duplication detector that catches copy-paste clones in the diff — followed by a clean-context review that never sees the conversation that wrote the code. Those gates have no permissive setting: a gate that softens for the cases it exists to police is worse than no gate, because it reports clean. Upstream, :design interviews you into a PRD and :tickets cuts an adversary-approved ticket tree from it. Every stage of every run is recorded to an append-only log — state machine, resume point and timing record in one file, with human waits bracketed so machine time is separable from a weekend away. Six commands and twelve internal workers. More at https://github.com/iansmith/slopstop

Bitranox skill collection: software-engineering workflow skills (planning, debugging, code review, clean architecture, language and tool references, humanizing) plus a self-improvement loop that captures session learnings into memory and CLAUDE.md, and PostToolUse hooks that validate JSON/YAML/XML edits and flag AI-writing tells in prose, feeding issues back for correction.

Build production mobile apps (Android + iOS, one codebase) with AI — the delivery harness for Kotlin/Compose Multiplatform. Use it when asked to create a mobile app, a cross-platform app, or any Android/iOS app: scaffolds a green-building app by interview, then holds any AI coding agent to a machine-enforced definition of done — a spec-driven verify lane that refuses "done" without a committed evidence receipt, a Stop hook that enforces it, in-project generation skills, an AI-native Compose inspector (structured JSON, never screenshots) and a live device-free preview loop. Eleven skills, each described where it lives; same engine as `npx create-cmp-cli`.

Pay down tech debt one verified fix at a time: point it at a suppression, a rule, or an outdated package, and it reports the blast radius before editing, fixes in gated batches, and commits each batch only once its acceptance gate passes.

Team-style feature delivery for Claude Code: a captain agent plans the work and delegates each step to backend, frontend, test, and design specialists behind hook-enforced guardrails, with a consolidated review gate before anything ships.

SignatureAPI is an e-signature API for developers: send documents for signature, embed signing in your app, and track progress with webhooks. This plugin adds skills to design, build and troubleshoot your integration and answer questions from the docs, plus the hosted MCP server.

Deeply inspect any repository from the ground up, determine its true current state, audit across 14 engineering and product domains, and construct a mature, prioritized, dependency-aware repository backlog of execution-ready tracker Issues without modifying application code.

Deeply inspect any repository from the ground up, determine its true current state, audit across 14 engineering and product domains, and construct a mature, prioritized, dependency-aware repository backlog of execution-ready tracker Issues without modifying application code.

Vendor-neutral UI component skills. Each skill ships a complete reference - semantic HTML, plain CSS custom properties, and dependency-free JavaScript - that an agent builds into your project in your stack. No framework, no design system, no package to install.

Route engineering work through explicit playbooks, evidence gates, unattended runs, and merge-ready draft PRs in Codex or Claude Code.

Specification-Driven Development framework for Codex. Provides skills for feature workflows, memory system, ideas pipeline, and project scaffolding.

Specification-Driven Development framework for Codex. Provides skills for feature workflows, memory system, ideas pipeline, and project scaffolding.

grep lost. Read the map. Includes 1 skill.

Consent-gated Linux host security assessment and network observation.

Standalone multi-scanner security orchestration for coding agents.

Set up, migrate, audit, and operate an Obsidian vault as an LLM Wiki — a persistent, compounding knowledge base maintained by Claude Code.

Understand and diagnose config-profile isolation on a machine running several Claude Code CLAUDE_CONFIG_DIR profiles or several Codex CODEX_HOME profiles, and report how much usage-limit budget each profile has consumed. Explains why Claude Code profiles that share a plugins store hit recurring "corrupted installLocation" errors and cross-profile plugin deletion, and why a Codex profile seeded by copying config.toml keeps reading the home it was copied from, including an MCP server that re-enters it. Ships a read-only health-check script for each, a usage-limit report covering every Claude Code profile and Codex home with reset times and Codex reset-voucher counts and expiry -- installable on PATH as `code-limit` -- and documents the reverse-engineered Claude Code CLI validation and garbage-collection mechanism behind the first.

High-fidelity literary book translation from a Gutenberg EPUB source (expert-mode `custom` extractor also supported), run to convergence through a codex-translate -> false-green gate -> codex-review -> Claude-fix loop over a frozen name/realia canon, with configurable verse policy, ledger resumability, and optional assembly into a rendered Obsidian glossary-wiki.

Author, capture, and publish a Diátaxis-structured end-user handbook for any project — methodology shipped as a reusable skill, project-specific bindings supplied via .claude/handbook/profile.yml.