Claude Mods

 ██████╗██╗      █████╗ ██╗   ██╗██████╗ ███████╗    ███╗   ███╗ ██████╗ ██████╗ ███████╗
██╔════╝██║     ██╔══██╗██║   ██║██╔══██╗██╔════╝    ████╗ ████║██╔═══██╗██╔══██╗██╔════╝
██║     ██║     ███████║██║   ██║██║  ██║█████╗      ██╔████╔██║██║   ██║██║  ██║███████╗
██║     ██║     ██╔══██║██║   ██║██║  ██║██╔══╝      ██║╚██╔╝██║██║   ██║██║  ██║╚════██║
╚██████╗███████╗██║  ██║╚██████╔╝██████╔╝███████╗    ██║ ╚═╝ ██║╚██████╔╝██████╔╝███████║
 ╚═════╝╚══════╝╚═╝  ╚═╝ ╚═════╝ ╚═════╝ ╚══════╝    ╚═╝     ╚═╝ ╚═════╝ ╚═════╝ ╚══════╝

A comprehensive extension toolkit that transforms Claude Code into a specialized development powerhouse.

claude-mods is a production-ready plugin that extends Claude Code with 103 specialized skills, 3 expert agents, 13 output styles, 13 hooks, and modern CLI tools designed for real-world development workflows. Whether you're debugging React hooks, optimizing PostgreSQL queries, or building production CLI applications, this toolkit equips Claude with the domain expertise and procedural knowledge to work at expert level across multiple technology stacks.

Built on the Agent Skills specification (an open standard backed by Anthropic, Vercel, Google, Microsoft, and 40+ agent platforms), claude-mods fills critical gaps in Claude Code's capabilities: persistent session state that survives across machines, on-demand expert knowledge for specialized domains, token-efficient modern CLI tools (10-100x faster than traditional alternatives), and proven workflow patterns for TDD, code review, and feature development. The toolkit implements Anthropic's recommended patterns for long-running agents, ensuring your development context never vanishes when sessions end.

From Python async patterns to Rust ownership models, from AWS Fargate deployments to Craft CMS development - claude-mods provides the specialized knowledge and tools that transform Claude from a general-purpose assistant into a domain expert who understands your stack, remembers your workflow, and ships production code.

3 agents. 103 skills. 13 styles. 13 hooks. 14 rules. One install.

Recent Updates

v3.7.0 (August 2026)

• 🆕 hono-ops skill - Hono v4 on Cloudflare Workers, distilled from a production multi-tenant Worker: composition and typed bindings, zValidator request validation, RPC, streaming, onError discipline, and testing under vitest-pool-workers - the companion piece to cloudflare-ops' runtime layer.
• 🎨 rembg-ops skill - transparent-PNG cutouts for flat illustration, sticker, and avatar art. A deterministic fallback ladder carries on where rembg's ML models fail on non-photographic input, so a batch job degrades predictably instead of silently mangling half the set.
• 🔍 repo-doctor skill + agentic-quality rule - the cold-agent doctrine, enforced: a read-only auditor scores any repo on entry docs, guard comments, structure, gates, and doc-pairing (--json + --strict for CI), paired with the rule that makes the doctrine binding on every task.
• 🌳 fleet-ops landing wave - the landing queue got session-aware: a live-owner gate (with a self-ownership exemption), a MAIN role for the integration checkout, fleet prune for stale worktree housekeeping, and a gate that now refuses to land when its test command is unarmed rather than passing vacuously.
• 📚 Battle-tested reference wave - production-mined depth for four skills: sqlite-ops D1 patterns (migrations that time out but apply, .batch() semantics, Sessions-API read replication), cloudflare-ops Workers runtime gotchas, typescript-ops TS 7 native-compiler adoption, and auth-ops Cloudflare Access + Better Auth.
• 🔄 fleetflow extracted - the heterogeneous-fleet skill (GLM / Codex / Grok / Anthropic workers) outgrew a skill directory and moved to its own repo, staying mounted as a skill via junction. An app with a dashboard and roadmap is a product, not a skill resource.

v3.6.0 (July 2026)

• 🎨 svg-brand-tint-ops skill — a zero-dependency in-browser SVG studio. Recolour any SVG to a brand palette via a token-driven tri-tone (feColorMatrix desaturate → feComponentTransfer grey-ramp remap → theme-aware CSS-filter bake), plus a from-scratch raster vectoriser (PNG → SVG) built on a Potrace-paper geometry stage — tolerance-tube straightness, penalty-DP optimal polygon, sub-pixel vertex adjustment, and alphamax corner analysis, reimplemented from the freely published Selinger 2003 paper (no GPL code) — over soft-field marching-squares with alpha-aware palette handling (matte de-blending, anti-alias fringe cull, blend-veto) that keeps flat-colour brand logos crisp. B&W / posterised / colour trace modes, a photographic filter stack, curated Google Fonts on SVG <text>, element hover-inspect, before/after split, and palette-from-image. Ships a ~90-line dependency-free static server (scripts/server.mjs), a headless trace CLI (scripts/trace.mjs) sharing one canonical engine with the browser tool (assets/trace-core.mjs, no drift), a colour-math + trace + theme-bake reference, and a 22-assertion offline test suite.

v3.5.0 (July 2026)

• 📐 isometric-ops skill — isometric illustrative assets end to end: creation, refinement, composition, and export for websites and games. 14 references anchor the exact projection math (true isometric 30° vs 2:1 dimetric 26.565° — the mislabel that breaks tilesets — with every constant derived and machine-checked by a §7 staleness verifier), coordinate transforms + y-sort depth doctrine, the tile-spec discipline, SVG/CSS/three.js generation, Aseprite pixel-art workflow, dual Blender ortho rigs (60° dimetric vs 54.736° true iso), engine tilemaps (Godot 4 / Unity / Phaser 3), and the full AI pipeline — Recraft/Midjourney/Flux+LoRA generation under ControlNet depth/MLSD structure control, upscale + vectorization ladders, and licence discipline that checks AI-training clauses. Scripts: iso-math.py (constants/transforms/grid generator), tile-validate.py (AI-tile QA: halo, bleed, anchor, palette), sheet-pack.py (spritesheet + atlas). Headlined by iso-studio — a zero-dependency browser scene composer with snap-to-grid staging, footprint-aware y-sort, docked control palettes, PNG/SVG/scene-JSON export, and a blockout mode that exports depth + lineart maps straight into ControlNet conditioning — built alongside the skill and extracted to its own repo (an app with a roadmap and asset library is a product, not a skill resource).

v3.4.0 (June 2026)

• 📊 r-ops skill — the set's first data-science skill: a tidyverse-first, current-best-practice reference for modern R (2024+). SKILL.md routes an import → tidy → transform → visualize → model → communicate workflow across 9 reference files (~115 KB) — tidyverse-core, import-io, strings-dates-factors, visualization, iteration-functional, modeling-stats, data-table, time-series, workflow-tooling. Leads with current idioms (native |>, dplyr .by=, the \(x) lambda, across(), list_rbind, slice_*, tidymodels, the tidyverts tsibble/fable stack, Quarto + renv) and names base R / data.table where they win. Ships a 43-assertion offline self-test plus a check-r-facts.py §7 staleness verifier (--offline asserts every catalogued CRAN package is still named in the prose and the currency note carries a year; --live resolves each package on CRAN) so the modern-stack claim is machine-enforced, not asserted. Salvaged and freshened from the stale stacked PR #6 (which also duplicated the already-shipped supply-chain-defense), re-landed clean off current main.

v3.3.0 (June 2026)

• 🔁 loop-ops skill — the outer-loop design discipline: how to design and safely run scheduled, autonomous agent loops — the orchestration layer above iterate (which drives a single inner run). Its backbone is a graduated-autonomy risk ladder (L1 report → L2 assisted → L3 unattended) mapped onto Claude Code's actual permission model, so a loop only ever gets the authority it has earned — anchored by the rule that a scheduler invokes claude -p, never a session spawning ungated children. Ships a 13-pattern morphology — trigger (cadence · event-driven Channels · /goal run-to-completion) × posture (L1–L3) × locus (connector→cloud routine · local→Desktop task) — plus a STATE/run-log/budget spine, multi-loop coordination, and a kill switch. Three tools do the work: loop-scaffold seeds a near-ready loop, loop-check refuses a green light on an unbounded scope / missing gate / undefined escalation, and loop-estimate gives caching-aware cost/month before you commit to a cadence. Composes fleet-worker (spawn) and fleet-ops (land).

v3.2.0 (June 2026)

• 🤖 fleet-worker skill — delegate tool-using, multi-step tasks to cheaper headless Claude Code workers — a cheaper Anthropic model (Sonnet/Haiku) or any Anthropic-compatible endpoint (e.g. GLM 5.2 via z.ai) — while an Opus orchestrator fans them out in parallel and gates their results before anything lands. Each worker is a real claude -p with Claude Code's full tool harness (Read/Write/Edit/Bash/Glob/Grep/Task) and any skills you provision into it, but a cheaper brain — isolated in its own git worktree + CLAUDE_CONFIG_DIR. Ships bash + PowerShell launchers, a result-gating collector, an endpoint health verifier, and the fleet-ops handoff recipes. fleet-worker is the spawn layer; fleet-ops is the test-gated landing layer it hands winning branches to. Provider-agnostic.

v3.1.0 (June 2026)

• 🗺️ mapbox-ops skill - advanced Mapbox GL JS for the web (v3): custom SVG/canvas markers and circular photo pins, thematic dataviz (choropleth, heatmaps, proportional symbols, 3D extrusions), terrain with hillshade and contours, cinematic flight/orbit camera and animated day–night cycles, style composition (v3 Standard slots + config, classic palette recolour, third-party styles), expression-driven styling, and the hard-won gotchas that silently drop your markers. 14 reference files plus a headless-Playwright marker-alignment verifier.
• 📐 Skill Creation Protocol - docs/SKILL-CREATION-PROTOCOL.md, the canonical "how to build a claude-mods skill" doc: one sequenced lifecycle (warranted? → frontmatter → body → resources → tests → repo wiring → ship) that cites the layer-owning docs rather than restating them, with a precedence table for when they disagree.
• 📋 adr-ops skill - Architecture Decision Records as a cross-project workflow. ADRs are append-only project memory: they capture why a system took its shape — the alternatives weighed, the constraints accepted — so a future maintainer recovers the reasoning without archaeology through git history or chat logs. Brings the when-to-write rule, canonical format, proposed→accepted→superseded lifecycle, and append-only supersession discipline, with five Resource-Protocol tools (init / new / index / touches-query / lint) and a 72-assertion suite.
• 📚 okf-ops skill - assess, validate, and adopt the Open Knowledge Format — Google Cloud's vendor-neutral spec (v0.1, Apache-2.0) for packaging organizational knowledge as a directory of markdown files with YAML frontmatter that AI agents can query without a platform or SDK. A read-only readiness scanner finds good adoption candidates across many repos; a conformance validator (--strict for CI) checks a bundle. Honest scope baked in — OKF is a v0.1 draft, adopt per-repo.
• 📦 pypi-ops skill - publish Python packages to PyPI the 2026 way: OIDC Trusted Publishing with PEP 740 attestations via gh-action-pypi-publish, not stored API tokens. First-publish pending-publisher setup, the invalid-publisher / "already exists" failure ladder, TestPyPI dry runs, release-environment approval gates, local uv publish / twine, and a stale-OIDC-federation audit.
• 🔍 github-ops repo-health auditing — know a repo's security posture at a glance, without leaving the terminal. A read-only auditor checks the controls that actually matter (Dependabot, secret + code scanning, private vulnerability reporting, SECURITY.md, branch protection) with visibility-aware severity, flags stale open issues as a pre-push advisory, and rolls it all into a scored repo-scorecard that grades a single repo — or an entire --org — in one pass. It emits the exact fix commands and never touches your repo, so you decide what to apply.

v3.0.0 (June 2026)

• Skills-first restructure - Breaking: the expert-agent layer was cut from 23 to 3. Per Anthropic's guidance, knowledge belongs in skills (progressive disclosure, single source of truth) and subagents are reserved for context isolation — so all domain-knowledge agents became -ops skills (the 11 language/framework experts → their twins; cypress/cloudflare/bash/craftcms/payloadcms/asus-router → new skills; claude-architect/aws-fargate folded into existing skills). The 3 remaining agents are pure isolation/worker roles: git-agent (background commits/PRs), firecrawl-expert (noisy multi-page scrapes), project-organizer (bulk restructure). Dispatching skills now route general-purpose agents that preload skill references.
• claude-code-ops skill - the machinery of Claude Code itself in one skill: the complete 30-event hook catalog with per-event stdin/stdout JSON contracts and all five hook types; the current SKILL.md frontmatter spec (when_to_use, context: fork, skill-scoped hooks); a headless/CLI reference (claude -p, stream-json, structured output, background agents); and extension-debugging decision trees. Merges and rebuilds the old claude-code-debug/-headless/-hooks skills against the live June-2026 docs - the stale $TOOL_INPUT hook contract is gone (stdin JSON is current), with claude-architect's extension-architecture guidance folded in.
• claude-api-ops skill - building applications on Claude: the Messages API, tool-use loops, prompt caching, structured outputs (output_config.format), the Batches API, extended/adaptive thinking, a current model-selection + pricing table, and the Claude Agent SDK (Python + TypeScript). Carries a cost-optimization checklist and a check-model-table.py verifier that flags model/pricing drift against the live API.
• playwright-ops skill - end-to-end testing done right: the role-first selector hierarchy and web-first assertions (no manual waits), fixtures / Page-Object patterns, network mocking and HAR replay, storageState auth, sharding and parallelism, visual regression, and a flake-hunting playbook with a triage-flakes.py ranker. Ships a production playwright.config.ts template.
• terraform-ops skill - Terraform/OpenTofu infrastructure-as-code: directory-per-environment layout, remote-state management (moved/import/removed, drift detection, state-surgery discipline), module composition, write-only secrets, and native terraform test. Ships an OIDC plan-on-PR / apply-on-merge GitHub Actions workflow template and a check-action-refs.sh verifier (the check that would have caught the trivy-action tag bug).
• ffmpeg-ops skill - probe-first ffmpeg/ffprobe operations: a ~30-command cookbook with a footgun table (seek/keyframe semantics, yuv420p+faststart, quoting, VFR), EDL-driven editing (edit-as-code - schema asset + cut-from-edl.py, dry-run by default), .cube/Hald-CLUT colour grading with a ~40-recipe look catalog (film stocks incl. CineStill halation, signature movie grades, an 18-variant tone-map family) and a human-picks-the-grade chooser, VMAF/SSIM quality gates, two-pass loudnorm, hardware-encoder proof-encoding (listed ≠ working), chapter authoring, target-size compression, scrub-preview sprites, Whisper/STT prep, and a probe --doctor that pairs each hazard with its exact fix command. 19 references, a verify-commands.sh §7 staleness verifier, 107-assertion self-test on lavfi-synthesized fixtures.
• ytdlp-ops skill - the yt-dlp media-acquisition layer feeding ffmpeg-ops: format-selection doctrine (-S sort over -f filters, codec targeting that avoids re-transcodes), clip-at-download (--download-sections), audio-only STT extraction (stream-copy -x), incremental channel syncs (the --break-on-existing --lazy-playlist cron pattern), cookies/auth (--cookies-from-browser, the Chrome 127+ Windows caveat), SponsorBlock, livestream/premiere capture, and a failure-triage ladder (nsig/403/429/geo, TLS-fingerprint blocks → --impersonate, the EJS no-JS-runtime class). 6 references, a check-ytdlp-version.sh §7 verifier (flags an install >60 days behind the latest release, or a core flag that vanished from --help), 28-assertion offline self-test.
• Live security guards, zero hand-wiring - config-change-guard.sh scans Claude settings files for worm-persistence IOCs the moment they're edited; worktree-guard.sh mechanically enforces worktree boundaries. Plugin-level hooks/hooks.json auto-wires the security set on install.
• Skill Resource Protocol - one build standard for skill scripts and assets (docs/SKILL-RESOURCE-PROTOCOL.md), headlined by the staleness-verifier pattern: offline checks gate PR CI, live drift checks run weekly without ever blocking a PR. Four verifiers ship with it.
• fleet-ops v2 - repositioned as landing discipline (sequential queue, test-gated merge, pre-land scrub, one-shot revert, new fleet track) on top of native agent teams and background agents, which now own session spawning.
• Docs that can't rot - new CHANGELOG.md; a CI doc-drift gate fails the build when README counts diverge from disk or a link goes ghost; every skill's behavioural suite runs in CI; /save + /sync repositioned as portable, team-shareable state alongside native auto-memory.

View full changelog →

Why claude-mods?

Claude Code is powerful out of the box, but it has gaps. This toolkit fills them:

• Session continuity — Tasks vanish when sessions end. We fix that with /save and /sync, implementing Anthropic's recommended pattern for long-running agents.

• Expert-level knowledge on demand — 103 on-demand skills covering React, TypeScript, Python, Go, Rust, PostgreSQL, and more, plus 3 specialized agents reserved for genuine context-isolation/worker roles (git operations, web scraping, project reorganization). Skills-first: knowledge loads when relevant instead of living in heavyweight agent prompts.

• Modern CLI tools — Stop using grep, find, and cat. Our rules automatically prefer ripgrep, fd, eza, and bat — 10-100x faster and token-efficient.

• Smart web fetching — A fallback hierarchy that actually works: WebFetch → Jina Reader → Firecrawl. No more "I can't access that URL."

• Workflow patterns — TDD cycles, code review, feature development, debugging — all documented with Anthropic's best practices.

Key Benefits

• Persistent task state — Pick up exactly where you left off, even across machines
• Domain expertise — Agents trained on framework docs, not just general knowledge
• Token efficiency — Modern CLI tools produce cleaner output, saving context window
• Team sharing — Git-trackable state files work across your whole team
• Production-ready — Validated test suite, proper plugin format, comprehensive docs
• Extended thinking — Built-in guidance for "think hard" and "ultrathink" triggers
• Zero lock-in — Standard Claude Code plugin format, toggle on/off anytime

Structure

claude-mods/
├── .claude-plugin/     # Plugin metadata
├── agents/             # Expert subagents (3)
├── commands/           # Slash commands (3)
├── skills/             # Custom skills (103)
├── output-styles/      # Response personalities
├── hooks/              # Hook examples & docs
├── rules/              # Claude Code rules
├── tools/              # Modern CLI toolkit installers
├── scripts/            # Plugin install scripts
├── tests/              # Test suites + justfile
├── docs/               # Project docs
└── templates/          # Extension templates

Installation

Plugin Install (Recommended)

# Step 1: Add the marketplace
/plugin marketplace add 0xDarkMatter/claude-mods

# Step 2: Install the plugin
/plugin install claude-mods@0xDarkMatter-claude-mods

This installs globally (available in all projects). Toggle on/off with /plugin menu.

Script Install

git clone https://github.com/0xDarkMatter/claude-mods.git
cd claude-mods
bash scripts/install.sh

Works on Linux, macOS, and Windows (Git Bash). A PowerShell alternative is also available at scripts/install.ps1.

The install scripts:

• Copy commands, skills, agents, rules, output styles to ~/.claude/
• Clean up deprecated items (e.g., old /conclave command)
• Remove renamed skills (e.g., -patterns -> -ops)
• Handle command→skill migrations (won't create duplicates)
• Preserve any extra skills installed separately (e.g., project-specific skills)

CLI Tools (Optional)

Install modern CLI tools (fd, rg, bat, etc.) for better performance:

# Windows (Admin PowerShell)
.\tools\install-windows.ps1

# Linux/macOS
./tools/install-unix.sh

Skill Architecture

All skills comply with the Agent Skills specification and follow a consistent structure:

skill-name/
├── SKILL.md              # Core workflow (< 500 lines)
├── scripts/              # Executable code (optional)
├── references/           # Documentation loaded as needed (optional)
└── assets/               # Output templates/files (optional)

Progressive Loading:

1. Metadata (name + description) - Always in context (~100 words)
2. SKILL.md body - Loaded when skill triggers (<5k words)
3. Bundled resources - Loaded only when Claude needs them

All skills have the complete directory structure, even if scripts/, references/, or assets/ are currently empty. This ensures consistency and makes it easy to add bundled resources later.

See skill-creator for the complete guide.

What's Included

Commands

Skills

Language & Framework Skills

Python Skills

Data & API Skills

Infrastructure Skills

Workstation & Network Diagnostics

CLI Tool Skills

Workflow Skills