claude-mods

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 22 expert agents, 42 specialized skills, 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 Anthropic's Agent Skills standard, 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.

22 agents. 42 skills. 3 commands. One install.

Recent Updates

v1.6.0 (February 2026)

• 🚀 NEW: Tech Debt Scanner - Automated detection using parallel subagents (1,520 lines)
  • Always-parallel architecture for fast analysis (2-15s depending on scope)
  • 4 categories: Duplication, Security, Complexity, Dead Code
  • Session-end workflow: catch issues while context is fresh
  • Language-smart: Python, JS/TS, Go, Rust, SQL with AST-based detection
  • Boris Cherny's recommendation: "Build a /techdebt slash command and run it at the end of every session"

v1.5.2 (February 2026)

• 🆕 Added cli-patterns, screenshot, skill-creator skills (+3 skills, now 42 total)
• 📚 Enhanced skill-creator with official Anthropic docs and best practices (+554 lines)
• 🐛 Fixed /sync filesystem scanning issue on Windows (Git Bash compatibility)

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 — 22 specialized agents covering React, TypeScript, Python, Go, Rust, AWS, PostgreSQL, and more. Each agent is deeply researched with real-world patterns, not generic advice.

• 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 (22)
├── commands/           # Slash commands (3)
├── skills/             # Custom skills (42)
├── 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 (PLAN.md, DASH.md)
└── 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

Linux/macOS:

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

Windows (PowerShell):

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

The install scripts:

• Copy commands, skills, agents, rules to ~/.claude/
• Clean up deprecated items (e.g., old /conclave command)
• Handle command→skill migrations (won't create duplicates)

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 follow Anthropic's official pattern with 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

Command	Description
sync	Session bootstrap - read project context, restore saved state, show status.
save	Save session state - persist tasks, plan content, and git context.
canvas	Terminal canvas for content drafting with live markdown preview. Requires Warp terminal. (Experimental)

Skills

Pattern Reference Skills

Skill	Description
cli-patterns	Production CLI tool patterns - agentic workflows, stream separation, semantic exit codes, OS keyring auth
rest-patterns	HTTP methods, status codes, REST design patterns
tailwind-patterns	Tailwind utilities, responsive breakpoints, config
sql-patterns	CTEs, window functions, JOIN patterns, indexing
sqlite-ops	SQLite schemas, Python sqlite3/aiosqlite patterns
mcp-patterns	MCP server structure, tool handlers, resources

CLI Tool Skills

Skill	Description
file-search	Find files with fd, search code with rg, select with fzf
find-replace	Modern find-and-replace with sd
code-stats	Analyze codebase with tokei and difft
data-processing	Process JSON with jq, YAML/TOML with yq
markitdown	Convert PDF, Word, Excel, PowerPoint, images to markdown
structural-search	Search code by AST structure with ast-grep

Workflow Skills

Skill	Description
tool-discovery	Recommend agents and skills for any task
git-workflow	Enhanced git operations with lazygit, gh, delta
doc-scanner	Scan and synthesize project documentation
project-planner	Track stale plans, suggest session commands
python-env	Fast Python environment management with uv
task-runner	Run project commands with just
screenshot	Find and display recent screenshots from common screenshot directories

Development Skills

Skill	Description
skill-creator	Guide for creating effective skills with specialized knowledge, workflows, and tool integrations.
explain	Deep explanation of complex code, files, or concepts. Routes to expert agents.
spawn	Generate PhD-level expert agent prompts for Claude Code.
atomise	Atom of Thoughts reasoning - decompose problems into atomic units.
setperms	Set tool permissions and CLI preferences in .claude/ directory.
introspect	Analyze previous session logs without consuming current context.
review	Code review with semantic diffs, expert routing, and auto-TaskCreate.
testgen	Generate tests with expert routing and framework detection.

Agents

Agent	Description
astro-expert	Astro projects, SSR/SSG, Cloudflare deployment
asus-router-expert	Asus routers, network hardening, Asuswrt-Merlin
aws-fargate-ecs-expert	Amazon ECS on Fargate, container deployment
bash-expert	Defensive Bash scripting, CI/CD pipelines
claude-architect	Claude Code architecture, extensions, MCP, plugins, debugging
cloudflare-expert	Cloudflare Workers, Pages, DNS, security
craftcms-expert	Craft CMS content modeling, Twig, plugins, GraphQL
cypress-expert	Cypress E2E and component testing, custom commands, CI/CD
firecrawl-expert	Web scraping, crawling, parallel fetching, structured extraction
go-expert	Go idioms, concurrency, error handling, performance
javascript-expert	Modern JavaScript, async patterns, optimization
laravel-expert	Laravel framework, Eloquent, testing
payloadcms-expert	Payload CMS architecture and configuration
postgres-expert	PostgreSQL management and optimization
project-organizer	Reorganize directory structures, cleanup
python-expert	Advanced Python, testing, optimization
react-expert	React hooks, state management, Server Components, performance
rust-expert	Rust ownership, lifetimes, async, unsafe patterns
sql-expert	Complex SQL queries, optimization, indexing
typescript-expert	TypeScript type system, generics, utility types, strict mode
vue-expert	Vue 3, Composition API, Pinia state management, performance
wrangler-expert	Cloudflare Workers deployment, wrangler.toml

Rules

Rule	Description
cli-tools.md	Modern CLI tool preferences (fd, rg, eza, bat, etc.)
thinking.md	Extended thinking triggers (think → ultrathink)
commit-style.md	Conventional commits format and examples
naming-conventions.md	Component naming patterns for agents, skills, commands
skill-agent-updates.md	Mandatory docs check before creating/updating skills or agents

Tools & Hooks

Resource	Description
tools/	Modern CLI toolkit - token-efficient replacements for legacy commands
hooks/	Hook examples for pre/post execution automation

Output Styles

Output styles customize Claude's response personality. Use /output-style to switch between them.

Style	Description
vesper	Sophisticated engineering companion with British wit, intellectual depth, and pattern recognition

Creating custom styles: Add a markdown file to output-styles/ with YAML frontmatter:

---
name: StyleName
description: Brief description of the personality
keep-coding-instructions: true  # Preserve Claude Code's core behavior
---

# Style content here...

Web Fetching Hierarchy

When fetching web content, tools are used in this order:

Priority	Tool	When to Use
1	WebFetch	First attempt - fast, built-in
2	r.jina.ai/URL	JS-rendered pages, PDFs, cleaner extraction
3	firecrawl <url>	Anti-bot bypass, blocked sites (403, Cloudflare)
4	firecrawl-expert agent	Complex scraping, structured extraction

See tools/README.md for full documentation and install scripts.

Testing & Validation

Validate all extensions before committing:

cd tests

# Run full validation (requires just)
just test

# Or run directly
bash validate.sh

# Windows
powershell validate.ps1

What's Validated

• YAML frontmatter syntax
• Required fields (name, description)
• Naming conventions (kebab-case)
• File structure (agents/.md, skills//SKILL.md)

Available Tasks

cd tests
just              # List all tasks
just test         # Run full validation
just validate-yaml # YAML only
just validate-names # Naming only
just stats        # Count extensions
just list-agents  # List all agents

Session Continuity

The /save and /sync commands fill a gap in Claude Code's native session management.

The problem: Claude Code's --resume flag restores conversation history, but task state does not persist between sessions—by design. Claude Code treats each session as isolated; the philosophy is that persistent state belongs in files you control.

Tasks (created via TaskCreate, managed via TaskList/TaskUpdate) are session-scoped and deleted when the session ends. This is intentional.

The solution: /save and /sync implement the pattern from Anthropic's Effective Harnesses for Long-Running Agents:

"Every subsequent session asks the model to make incremental progress, then leave structured updates."

What Persists vs What Doesn't

Claude Code Feature	Persists?	Location
Conversation history	Yes	Internal (use --resume)
CLAUDE.md context	Yes	./CLAUDE.md
Tasks	No	Deleted on session end
Plan Mode state	No	In-memory only

Session Workflow

Session 1:
  /sync                              # Bootstrap + restore saved state
  [work on tasks]
  /save "Stopped at auth module"     # Writes .claude/session-cache.json

Session 2:
  /sync                              # Restore tasks, show status
  → "In progress: Auth module refactor"
  → "Notes: Stopped at auth module"
  /sync --status                     # Quick status check anytime

Why Not Just Use --resume?

Feature	--resume	/save + /sync
Conversation history	Yes	No
Tasks	No	Yes
Git context	No	Yes
Human-readable summary	No	Yes
Git-trackable	No	Yes
Works across machines	No	Yes (if committed)
Team sharing	No	Yes

Use both together: claude --resume for conversation context, /sync for task state.

Session Cache Schema (v3.0)

The .claude/session-cache.json file stores full task objects:

{
  "version": "3.0",
  "tasks": [
    {
      "subject": "Task title",
      "description": "Detailed description",
      "activeForm": "Working on task",
      "status": "completed|in_progress|pending",
      "blockedBy": [0, 1]
    }
  ],
  "plan": { "goal": "...", "current_step": "...", "progress_percent": 40 },
  "git": { "branch": "main", "last_commit": "abc123" },
  "notes": "Session notes"
}

Migration: /sync auto-detects v2.0 files (legacy todos format) and migrates them. Run /save after migration to upgrade the file.

Updating

git pull

Then re-run the install script to update your global Claude configuration.

Performance Tips

MCP Tool Search

When using multiple MCP servers (Chrome DevTools, Vibe Kanban, etc.), their tool definitions consume context. Enable Tool Search to load tools on-demand:

// .claude/settings.local.json
{
  "env": {
    "ENABLE_TOOL_SEARCH": "true"
  }
}

Value	Behavior
"auto"	Enable when MCP tools > 10% of context (default)
"auto:5"	Custom threshold (5%)
"true"	Always enabled (recommended)
"false"	Disabled

Requirements: Sonnet 4+ or Opus 4+ (Haiku not supported)

Skills Over Commands

Most functionality lives in skills rather than commands. Skills get slash-hint discovery via trigger keywords and load on-demand, reducing context overhead. Only session management (/sync, /save) and experimental features (/canvas) remain as commands.

See docs/COMMAND-SKILL-PATTERN.md for details.

Resources

• Claude Code Best Practices — Official Anthropic guide
• Claude Code Plugins — Plugin system documentation
• Effective Harnesses for Long-Running Agents — The pattern behind /save

---

Extend Claude Code. Your way.