claude-mods

Flags accessibility misses as Claude writes UI: images without alt, unlabeled buttons, clickable divs.

Unlock achievements as you work: first commit, 100 green test runs, a week-long streak and more.

A heat map of when you use Claude Code, by hour and weekday.

Ready-made subagents for focused jobs: debugger, test writer, doc writer and migrator.

Writes every action Claude takes to an append-only JSONL audit log.

Snapshots your work tree before every editing turn and lets you /rollback to any checkpoint.

Formats every file Claude edits with the right formatter for its language.

Give it a goal and success criteria; it plans, delegates, verifies and retries until the criteria pass or it needs you.

Dumps your local database before every migration so a bad one is one command away from undo.

/bash-history lists recent shell commands Claude ran, with exit status and duration.

/bench runs your benchmarks before and after a change and compares the numbers.

Stops full reads of huge files and nudges toward offset/limit or grep.

/bookmark saves the last answer; /bookmarks lists and reuses them.

/git-branch creates a well-named git branch from a short task description.

Reminds you to stand up and stretch every 50 minutes of active work.

Compares bundle size after each build and warns when it grows.

Shows what share of input tokens came from the prompt cache.

Reads your calendar (private iCal link) so notifications and questions respect meetings and time off, and suggests slots for long jobs.

Celebrates when failing tests go green again.

Keeps CHANGELOG.md's Unreleased section up to date as you commit.

/cheat shows a quick reference for git, docker, regex, tmux and more, offline.

/ci-watch follows your GitHub Actions run and tells you the moment it passes or fails.

Checks edited GitHub Actions workflows and warns about actions not pinned to a version.

Warns before commands that create expensive cloud resources like GPU instances or large databases.

Adds configurable Co-authored-by trailers to commits Claude makes.

/map builds a compact map of your repository and gives it to Claude.

Shows who owns a file (from CODEOWNERS) as Claude edits it.

Suggests Claude Code commands and mods that fit the way you work.

/commit writes a Conventional Commit message from your staged diff and commits it.

Suggests /compact at natural breakpoints, before the context gets tight.

/components lists your existing UI components so Claude reuses them instead of creating duplicates.

/concise toggles short, to-the-point answers.

Detects merge-conflict markers and walks you through resolving each one.

A slim band above the prompt showing how full the context window is.

Keeps the context lean automatically: trims noise, picks the right moment to compact and shows the tokens it saved.

Checks that the colors Claude changes in CSS meet WCAG AA contrast.

/copy-last copies Claude's last answer (or its last code block) to the clipboard.

Flags pasted code that carries someone else's license or copyright header.

Live session cost estimate in the status line, from real token usage.

Flags weak cryptography: MD5 or SHA1 for passwords, Math.random for tokens, ECB mode, hard-coded IVs.

Flags hard-coded hex colors and pixel values where your design tokens should be used.

/peek shows a CSV or JSONL file's columns, sample rows and inferred types without reading the whole file.

Blocks piping downloaded scripts straight into a shell.

/curl2code turns a curl command into fetch, axios, Python requests or Go code.

/daily-goal sets today's goal, keeps it in view above the prompt and asks at day's end if you got there.

Tracks spend per day and week across sessions with a /spend report.

Flags colors added without a dark-mode variant in projects that support a dark theme.

/data-map lists where your code collects, stores and sends personal data — a head start for GDPR.

Gives Claude the current date, time zone, branch and OS on every prompt.

Warns when console.log, print, debugger or dbg! statements are left in code.

/decide records an Architecture Decision Record in docs/decisions.

Flags typosquatted or brand-new packages before npm, pip or cargo installs them.

Shows a pre-deploy checklist (tests, branch, changelog) and asks you to confirm before deploying.

Native desktop notifications when Claude finishes or needs you.

Starts your dev server in the background and shows its errors in a live pane.

A live pane listing changed files with +/- line counts, updated after every edit.

Posts progress and reports to Discord and takes questions and commands from a channel, through the mods-hub channel system.

Warns when the disk is nearly full before builds, installs and docker pulls.

After Django model changes, checks for missing migrations and offers to create them.

Flags Dockerfile smells: :latest tags, running as root, apt without cleanup, ADD instead of COPY.

Blocks docker system prune -a --volumes and volume deletion that can wipe local databases.

Plays a chime when a long turn finishes.

Asks for confirmation when a single turn tries to modify more than N files.

Daily or weekly email summaries in plain language for clients and managers who don't live in chat.

Keeps .env.example in sync with the environment variables your code actually reads.

Protects .env files, SSH keys and credential stores from being read or modified.

A short buzz when a command or test run fails.

Collects every failed command and tool error in one pane.

/explain-diff explains in plain words what changed in the last turn and why.

/eli5, /normal and /expert set how deep Claude's explanations go.

Warns when an edited file grows past a size that hurts readability.

A pane of every file read, edited or created in the session, with counts.

/fixtures generates realistic test data that matches your schema or types.

Detects tests that pass and fail at random and keeps a list of the suspects.

A Pomodoro timer in the status line with focus and break cycles.

Forbids force-pushing to protected branches and suggests --force-with-lease.

Warns before node_modules, build output, OS junk or huge files get staged.

Shows the current branch, ahead/behind and dirty file count in the status line.

Teaches Claude your project's vocabulary and injects definitions when you use the terms.

Runs go mod tidy when Claude changes Go imports, so go.mod and go.sum stay in sync.

Gives Claude a compact summary of your GraphQL schema when you work on queries and resolvers.

One security policy for every guard mod — permissive, standard or strict — plus a project safety score.

/handoff writes a handoff note so a teammate can pick up exactly where you left off.

Warns when large images, videos or fonts are added to the project.

Injects your team's style guide (STYLE.md) into the system prompt automatically.

/http sends a request and shows the formatted response in a pane, like a tiny Postman in your terminal.

Flags hard-coded user-facing strings in UI components.

Reminds you about uncommitted changes after a stretch of inactivity.

/issue turns the current conversation into a well-structured GitHub issue.

Picks up a GitHub, Jira or Linear issue, sizes it with smart-router, works it in a dedicated session and opens the PR.

/jwt decodes a JSON Web Token locally — header, claims, expiry — without sending it anywhere.

Turns kubectl apply into a server-side dry run with a diff you approve first.

Makes Claude always answer in your language while keeping code in English.

Flags event listeners, intervals and subscriptions created without cleanup.

Claude explains the why behind each change and leaves small TODOs for you to complete yourself.

When Claude fixes a mistake, offers to save the lesson to CLAUDE.md.

Warns when a dependency with a copyleft license (GPL, AGPL) lands in a permissively licensed project.

Adds your license header to every new source file Claude creates.

/lighthouse runs Lighthouse on a URL and shows performance, a11y, SEO and best-practice scores in a pane.

Collects every URL from the conversation into one list.

Runs the linter on each edited file and hands the errors straight back to Claude.

Prevents hand-editing lockfiles; they must change through the package manager.

/tail follows a log file or container in a live pane, with an errors-only filter.

Alerts you when a single command has been running too long.

Stops Claude when it repeats the same failing command three times and suggests a different approach.

Warns you the moment Claude starts editing files directly on main or master.

Prevents editing database migrations that already exist; write a new one instead.

Gives new migrations consistent, descriptive, timestamped names.

One dashboard for every Claude session on your machine: what each is doing, cost, blockers, with pause and priorities.

/mock starts a fake API server from your OpenAPI spec so you can build the frontend before the backend.

Recommends the right mods for your project and for what you're asking, with the commands to type, and installs them in one click.

/mod-doctor checks your installed mods for outdated versions, conflicts and load errors.

Suggests a cheaper model when your prompt is simple, and a stronger one when it is hard.

/new-mod scaffolds a new Claude Code mod with manifest, hooks, test and README, ready to fill in.

Switch between sets of mods — work, personal, demo — with one command.

The shared core that lets mods talk to each other: one event bus, one side panel with tabs, one place that routes notifications to your channels.

An in-terminal app store: browse, search, install and update every Claude Mod from GitHub.

Detects which monorepo package you're in and scopes test, lint and build commands to it.

Automatically retries commands that failed because of a temporary network error.

Flags missing or needless "use client" and server-only imports leaking into client components in Next.js.

Runs your queued tasks at a scheduled time, like overnight, and leaves you a report.

Flags new any types, @ts-ignore and eslint-disable comments as Claude writes them.

Warns when your Node version doesn't match .nvmrc, .node-version or package.json engines.

Blocks Claude from silencing tests with .skip, .only, xit or skip markers.

Blocks commands that upload files to external services like pastebins and file-sharing sites.

Spots database queries inside loops, the classic N+1 problem, as Claude writes them.

/offline blocks every network call — fetches, curl, installs, git push — until you turn it back on.

/tour walks a newcomer through the repository step by step.

Warns when your API routes change but openapi.yaml doesn't.

/outdated shows stale dependencies and how risky each upgrade is.

Trims huge command outputs to head, tail and error lines before they flood the context.

Claude proposes, you type: edits become diffs you apply yourself, for deliberate practice.

/explore sends three subagents to investigate different parts of the codebase and merges their findings.

Allows writes only inside the project root, resolving symlinks and .. tricks.

Keeps a log of every tool call that was denied, and why.

Pings you with a sound and toast when Claude is waiting on your approval.

/persona switches Claude between reviewer, architect, teacher and other roles.

Flags log statements that print emails, passwords, tokens or other personal data.

Before a dev server starts, tells you if the port is already taken and by which process.

/pr-desc drafts a pull request title and description from your branch diff.

Stops production-affecting commands (terraform apply, kubectl on prod, DROP TABLE) unless explicitly allowed.

/profile runs a command under a profiler and shows the hottest functions.

A self-organising project memory that learns which decisions, conventions and fixes matter and recalls them like a neural network.

/enhance rewrites your draft prompt into a precise, well-scoped request.

/history searches every prompt you have sent across sessions and reuses one.

Gently flags vague prompts like 'fix it' and suggests what to add.

Type :review:, :tests: or your own shortcodes and they expand into full prompts.

/explain-query runs EXPLAIN on your local database and explains the plan in plain words.

Adds a LIMIT to ad-hoc SELECTs Claude runs in psql, mysql or sqlite so results don't flood the context.

Short aliases like /t, /l and /b that run your test, lint and build commands.

/quiet silences toasts and sounds from every mod while you focus.

/quiz asks you questions about the code Claude just wrote, to check you really understand it.

/quote pastes your mouse selection into the prompt as a Markdown quote.

Stops Claude from hammering external APIs with curl loops.

Catches React hook mistakes as Claude writes them: missing effect deps, setState in render, conditional hooks.

Warns when public APIs, CLI flags or env vars change but the docs do not.

Gives Claude a recall tool to search your saved notes, decisions and journal.

/recent lists the files read and edited in this session, newest first.

Masks secrets and personal data in tool results before the model ever reads them.

Remembers which tests passed at the start of the session and warns if any of them now fail.

Shows what you were working on last time when a new session starts.

Adds a dedicated code-reviewer subagent and a /review command.

Blocks catastrophic shell commands like rm -rf /, mkfs, dd to disks and chmod -R 777.

/sbom generates a software bill of materials with every dependency and its license.

A pane of your local database's tables and columns, ready to hand to Claude as context.

After Prisma or Drizzle schema edits, regenerates the client and warns when a migration is missing.

/scope locks Claude to the files you name; edits outside the scope are blocked.

A persistent per-project notes pane you can type into without leaving Claude Code.

After UI edits, takes a Playwright screenshot of the page and shows it to Claude.

/second-opinion has a different model critique Claude's last answer or plan.

Blocks edits and writes that would commit API keys, tokens or private keys.

Blocks database seed, reset and drop commands unless DATABASE_URL points at your own machine.

At the end of each editing turn, has the model double-check it actually did what you asked.

Writes a dated journal entry of what was done when the session ends.

/replay steps through the session — prompts, tool calls, edits — in a pane, like a video timeline.

/session-stats shows a dashboard of turns, tools, tokens, cost, duration and files.

Coordinates sessions working on the same repo: file leases against conflicts, overlap warnings and hand-offs.

Exports and imports your mods' configuration so you can move it between machines.

One tip a day about Claude Code shortcuts and features you might not know.

Tracks which languages and tools you've worked with each week.

Posts progress and reports to Slack and takes questions and commands from a channel, through the mods-hub channel system.

Points out your slowest tests after each test run.

Routes every subagent to the right model for the task's difficulty, runs independent work in parallel and starts workflows when a job needs one.

Save and reuse code snippets across projects with /save-snippet and /snippet.

Sound packs for Claude Code events: minimal, retro or nature.

Reads a one-line summary of what Claude did out loud when a turn ends.

Flags UPDATE and DELETE without WHERE in .sql files and in queries inside your code.

Detects your stack and gives Claude the right conventions for it.

/standup summarises what you did yesterday, from git history, ready to paste.

/service-status checks whether GitHub, npm, PyPI or the Anthropic API are having an outage before you blame your code.

Reminds you to add a story when Claude creates a new component without one.

Shows your consecutive days of coding with Claude in the status line.

Adds declare(strict_types=1) to new PHP files and from __future__ import annotations to new Python files.

Caps how many subagents can run at the same time.

Watch running subagents live: type, status, duration and last activity.

/queue lines up prompts that run one after another whenever Claude is free.

A shared panel of team conventions, recommended mods, budgets and rules, synced through the repo.

Progress, questions and remote control over a Telegram bot, through the mods-hub channel system.

Shows terraform plan as a clear pane of resources to create, change and destroy.

A TDD mode: no production code changes until a test has been written or changed.

Runs the tests related to what changed and shows pass/fail in the status line.

Turns ticket references like ABC-123 or #42 into links and context for Claude.

A live pane of Claude's current task list with progress.

Notices every TODO, FIXME and HACK Claude adds and lists them at turn end.

Set a token or dollar budget per session; get warned at 80% and stopped at 100%.

A sparkline of tokens per turn right above the prompt.

A timeline pane of every tool call with duration, status and input summary.

Blocks adding analytics and tracking SDKs that haven't been approved.

Times every turn and tells you when one runs long.

Type-checks the project at the end of every editing turn so errors never slip by.

Restricts WebFetch to the domains you allow.

Blocks pip install outside an active virtualenv so system Python stays clean.

After installs, runs npm audit or pip-audit and shows any vulnerabilities in a pane.

Blocks watch-mode and never-ending commands run in the foreground, where they'd hang the turn.

Posts to Slack, Discord, Teams or ntfy when a long task finishes.

/sources lists every page Claude fetched or searched this session.

Lets Claude keep you posted on WhatsApp — progress, problems, reports, questions — and lets you steer every session from your phone, through one self-hosted OpenWA number.

Records why each file was changed; /why shows the reasoning behind any file's edits.

Build, save and share reusable workflows — release, dependency update, security audit — and run them with one command.