# Claude Code Mods: What They Are, Examples, and How to Install or Make One

> Claude Code mods are plugins whose JavaScript runs inside Claude Code: they can draw panes, add instant /commands and step into tool calls. What a mod can do, Anthropic's sample and built-in mods, how to install one safely, a first mod tested on Claude Code 2.1.302 with the real validate and test output, and why a mod does nothing.

By Tahir Nazir · Published 2026-11-17 · Updated 2026-11-17
Canonical: https://www.its-tahir.com/blog/claude-code-mods

**Claude Code mods are plugins whose JavaScript or TypeScript runs inside Claude Code itself. Claude Code calls a mod's functions, called hooks, when something happens, such as a tool call, a prompt or the spinner being drawn, and the mod can watch it, change it or answer it. That's how a mod draws its own pane, adds a `/command` that runs instantly, or holds a risky `rm -rf` until you confirm. Anthropic launched the feature as "Claude Mods" in Claude Code 2.1.287 on 1 October 2026; install one with `/plugin install name@marketplace`, or try one for a single session with `claude --plugin-dir ./the-mod`.**

| You want to | Do this |
|---|---|
| See mods that already exist | Anthropic's samples: `token-weather`, `blast-radius`, `replay-theater` ([below](#what-are-some-claude-code-mod-examples)) |
| Install a mod | `/plugin install name@marketplace`, then `/reload-plugins` |
| Try one without installing | `claude --plugin-dir ./the-mod` |
| Check a mod before trusting it | `claude plugin validate ./the-mod` and read the `hooks:` and `calls:` lines |
| Make your own | Ask Claude in a session, or write the three files yourself ([tested below](#how-do-i-make-my-own-claude-code-mod)) |
| A mod does nothing | `claude plugin validate`, then `claude plugin test` ([why both](#why-does-my-claude-code-mod-do-nothing)) |
| Turn mods off | `/plugin` > Installed, or `claude --safe-mode` for one session |

*Last reviewed 17 November 2026, against Anthropic's mods documentation and the Claude Code changelog to 2.1.326. I built and broke the tutorial mod myself on Claude Code 2.1.302 on Windows, in a throwaway folder with nothing installed; every command output below is copied from those runs. I didn't test panes or the band above the prompt, which need an interactive session.*

![How a Claude Code mod works: plugin.json, hooks/hooks.json with a modules key, and hooks/register.js; on tool.call, command.run or ui.render a hook can observe with next(e), rewrite with next({...e}) or answer with return. Check with claude plugin validate and claude plugin test; validate passed a mod that throws at load. Mods need Claude Code 2.1.287 and are not sandboxed.](https://www.its-tahir.com/blog/claude-code-mods/claude-code-mods-how-it-works.svg)

*A mod is three files; each hook can observe, rewrite or answer the event it handles.*

## What is a Claude Code mod?

**A mod is a [plugin](https://code.claude.com/docs/en/plugins/overview) with a hooks module: a JavaScript or TypeScript file whose functions Claude Code calls from inside its own process when events happen.** Settings hooks, skills and MCP servers work from outside Claude Code: each one runs a script, or gives Claude text or tools. A mod's code runs inside Claude Code's own process, so it can do things they can't. From Anthropic's [mods overview](https://code.claude.com/docs/en/plugins/mods/overview), a mod can:

- **Draw an interface you can use:** a pane beside the transcript or a band above the prompt, with tabs, buttons and text fields
- **Redraw Claude Code's own interface:** restyle a tool call's row, the spinner or the question dialog (but not the permission prompt)
- **Step into a tool call or a request:** hold a call while it asks you something, answer it without running the tool, or send one request to a different model
- **Run your own code on a command:** a `/command` that runs at once, with no Claude turn, even while Claude is working
- **Share data between hooks:** one hook counts tool calls while another shows the count beside the spinner

Each hook gets three things: `$`, the mods API (every way a mod can reach outside itself, such as `$.ui` or `$.command`); `e`, the event; and `next`, which passes the event on. A hook that returns `next(e)` only **observes** the event. A hook that calls `next` with a changed copy **rewrites** it. A hook that returns its own result and never calls `next` **answers** it, so Claude Code's usual behavior doesn't run.

### What is the difference between a Claude Code mod and a hook?

**A settings hook is a shell command, HTTP request or prompt that runs on an event and can allow, block or log it; a mod is code running inside Claude Code that can do the same and also draw in the interface, add instant commands and rewrite events.** Anthropic's docs call a mod's handlers hooks too, and the settings-file kind "settings hooks". Here is how both compare with skills and MCP servers:

| | Mod | Settings hook | Skill | MCP server |
|---|---|---|---|---|
| What it is | Functions Claude Code calls in its own process | A shell command, HTTP request or prompt run on an event | A `SKILL.md` file of instructions | An outside process that gives Claude tools |
| Can it draw in the interface | Yes | No | No | No |
| You write | JavaScript or TypeScript | A script plus a `settings.json` entry | Markdown | A server in any language |
| Pick it when | You want a pane, an instant command, or to rewrite an event | You want to block, allow or log an event with a script | You keep pasting the same instructions | Claude needs to reach an outside system |

The table is condensed from Anthropic's. A single plugin can ship a mod, a skill and an MCP server together. If you only need tools for Claude, an MCP server is still the right shape: see [how to build an MCP server](/blog/how-to-build-an-mcp-server) and [why one doesn't show up](/blog/mcp-server-not-showing-up-in-claude-code).

## What are some Claude Code mod examples?

**Anthropic publishes three sample mods (token-weather, blast-radius and replay-theater) in its claude-code-playground repository, and the source of built-in mods such as diff, agents-md, sec-default and telemetry in the anthropics/claude-code repository.**

| Mod | What it does | Where |
|---|---|---|
| `token-weather` | Draws a forecast of your context window above the prompt | [Sample](https://github.com/anthropics/claude-code-playground/tree/main/claude-code/mods/token-weather) |
| `blast-radius` | Holds a risky shell command, such as `rm -rf` or a force push, shows what it would change, with buttons to proceed or cancel | [Sample](https://github.com/anthropics/claude-code-playground/tree/main/claude-code/mods/blast-radius) |
| `replay-theater` | Adds `/replay`, which steps through the file edits Claude made in the last turn | [Sample](https://github.com/anthropics/claude-code-playground/tree/main/claude-code/mods/replay-theater) |
| `cc-plugin-diff` | Takes over `/diff` and draws its pane | [Built in](https://github.com/anthropics/claude-code/tree/main/mods/diff) |
| `cc-plugin-agents-md` | Loads `AGENTS.md` as project instructions | [Built in](https://github.com/anthropics/claude-code/tree/main/mods/agents-md) |
| `cc-plugin-sec-default` | The guard that stops a user's mod overriding your organization's rules | [Built in](https://github.com/anthropics/claude-code/tree/main/mods/sec-default) |
| `cc-plugin-you-should-know` | A side agent that shows a note above the prompt when it spots something you might have missed (off until you turn it on) | Built in ([2.1.287 changelog](https://github.com/anthropics/claude-code/blob/main/CHANGELOG.md)) |

`blast-radius` is the one I'd read first if you've ever had an agent delete something: it's a working example of answering a tool call before it runs, which is the same problem [Claude Code deleted my files](/blog/claude-code-deleted-my-files) is about. The `agents-md` mod is also why Claude Code now reads `AGENTS.md`; [how Claude Code and Cursor load project instructions](/blog/claude-code-vs-cursor-context-management) covers what that file does.

Anthropic shares the samples "as they are, without support".

### Where to find more Claude Code mods

Beyond Anthropic's repositories, people publish mods on GitHub and in unofficial directories such as claudemod.com, which shows up in Google results for "claude code mods". I haven't vetted any of them. Treat every one like code you'd run with your own permissions: clone it, run `claude plugin validate` on it, and read its `calls:` line before you install ([below](#are-claude-code-mods-safe)).

## How do I install a Claude Code mod?

**A Claude Code mod installs like any plugin: run `/plugin install name@marketplace` in a session, or `claude plugin install name@marketplace` in your shell, on Claude Code 2.1.287 or later.**

```bash
# In a Claude Code session
/plugin install token-weather@claude-code-playground-mods

# Or in your shell
claude plugin install token-weather@claude-code-playground-mods
```

That example assumes you've added Anthropic's sample marketplace, as described below.

If a session is already open when you install from the shell, run `/reload-plugins` in it; otherwise the mod loads next time you start Claude Code. To confirm it loaded, run `/plugin`; per Anthropic's docs, a dim line under the tabs reads like `1 mod active · token-weather`. Built-in mods aren't counted on that line.

**To try a mod without installing it,** clone its folder and load it for one session:

```bash
git clone https://github.com/anthropics/claude-code-playground
claude --plugin-dir ./claude-code-playground/claude-code/mods/token-weather
```

To keep a sample, add the clone's `claude-code/mods` folder as a marketplace with `/plugin marketplace add ./claude-code-playground/claude-code/mods`, then install from `claude-code-playground-mods`. The marketplace points at your clone, so the mod stops loading if you move or delete that folder.

You need Claude Code 2.1.287 or later in the terminal. The Desktop app bundles its own copy of Claude Code, and Anthropic's overview says mods work there from 2.1.286. Run `claude --version` to check, and update Claude Code if you're older.

## Are Claude Code mods safe?

**A mod is exactly as trustworthy as its author: it runs with your permissions, inside Claude Code, and it isn't sandboxed.** Anthropic's docs list what an installed mod can do:

- Read and write files anywhere your account can, start programs and make network requests
- Read your secrets, including an API key in your environment or settings
- See every prompt you send and every tool call Claude makes
- Rewrite a prompt or tool call, or submit a prompt as if you typed it
- Approve a tool call before you're asked
- Spend your usage by calling a model on your plan or API key

[Sandboxing](/blog/claude-code-sandbox) doesn't help here: it isolates the Bash commands Claude runs, and a process a mod starts runs outside it. Two limits do hold: a mod can't restyle the permission prompt, and where the built-in `sec-default` guard loads, a user's mod can't approve a call your `deny` or `ask` rules would stop. If you rely on [auto mode](/blog/claude-code-auto-mode) for safety, know that a mod changing a tool call's input after review gets the call denied with `a hook changed this call's input after the model wrote it`.

**Before you install one, read what it does without running it:**

```bash
claude plugin validate ./some-mod
```

The `hooks:` line lists the events it handles and the `calls:` line every mods API method it calls. A `calls:` line with `$.process.spawn`, `$.process.run`, `$.http.fetch` or `$.fs` methods is worth reading the code for: those start programs, reach the network or touch your files.

## How do I make my own Claude Code mod?

**Easiest: describe it in a Claude Code session, such as `make a mod that shows the current git branch above the prompt`. Claude uses the built-in `plugin-authoring` skill, writes the mod under `~/.claude/dev-mods/<session-id>/`, and asks whether to turn on hot reloading for the session.** In `auto` and `bypassPermissions` modes it can load the mod without asking; start in `default` mode if you want to approve each file. A mod Claude writes only loads in that session, so copy its folder somewhere permanent and load it with `--plugin-dir` to keep it.

To understand the code, write Anthropic's tutorial mod yourself. I did, on Claude Code 2.1.302 on Windows. It's three files:

`first-mod/.claude-plugin/plugin.json`, the manifest:

```json
{
  "name": "first-mod",
  "version": "0.1.0",
  "description": "Counts Claude's tool calls, shows the count beside the spinner, and adds a /tally command",
  "author": { "name": "Tahir Nazir" }
}
```

`first-mod/hooks/hooks.json`, which points at the code:

```json
{
  "description": "The first-mod hooks module",
  "modules": ["./register.js"]
}
```

`first-mod/hooks/register.js`, the hooks module:

```typescript
let calls = 0

export function register(on) {
  on('session.start', async ($, e, next) => {
    await $.command.register({
      name: 'tally',
      description: 'Show how many tool calls Claude has made',
    })
    return next(e)
  })

  on('tool.call', async ($, e, next) => {
    calls += 1
    $.ui.invalidate('ui.render')
    return next(e)
  })

  on('command.run', { command: 'tally' }, async () => {
    return { text: 'Claude has made ' + calls + ' tool calls since this mod loaded' }
  })

  on('ui.render', { component: 'Spinner' }, async ($, e, next) => {
    return next({ ...e, props: { ...e.props, suffix: ' · tool calls: ' + calls + '…' } })
  })
}
```

The `"modules"` key in `hooks.json` is what makes a plugin a mod. No Node.js, bundler or build step is needed: Claude Code loads `.js` and `.ts` files directly.

### What validate, test and a headless run printed

`claude plugin validate` reads the code without running it and lists what Claude Code will see:

```text
  ❯ ./register.js hooks: session.start, tool.call, command.run{command=tally}, ui.render{component=Spinner}
  ❯ ./register.js answers its own command: command.run{command=tally}
  ❯ ./register.js gating hook without .catch: tool.call
  ❯ ./register.js calls: $.command.register, $.ui.invalidate

✔ Validation passed
```

The `gating hook without .catch` line is a nudge, not an error: a `tool.call` hook can refuse calls, and Claude Code wants to know what happens if it fails.

`claude plugin test` runs a mod's tests with no session, sign-in or network. With Anthropic's sample test (two fake tool calls, then `/tally`) in `tests/first-mod.test.ts`:

```text
tests\first-mod.test.ts:
(pass) /tally reports the tool calls the mod has seen [100.48ms]

 1 pass
 0 fail
Ran 1 test across 1 file. [0.47s]
```

And the command, run headless from PowerShell (no model call, because the mod answers it):

```powershell
claude -p "/tally" --plugin-dir ./first-mod
```

```text
first-mod: Claude has made 0 tool calls since this mod loaded
```

Claude Code puts the mod's name in front of the command's text. On Windows, run that from PowerShell or cmd, not Git Bash: Git Bash rewrites an argument starting with `/` into a Windows path (`MSYS_NO_PATHCONV=1` turns that off).

I didn't run the interactive version. Per Anthropic's tutorial, if you start `claude --plugin-dir ./first-mod` and ask Claude to do something with a few tool calls, the spinner reads like `Thinking · tool calls: 2…`, and saving a change to `register.js` hot-reloads the mod. A reload runs `register` again, so `calls` resets to 0.

## Why does my Claude Code mod do nothing?

**Claude Code skips a mod that fails and carries on, so a broken mod looks like one that does nothing. Run `claude plugin validate` on its folder first, then `claude plugin test`, because validate only reads the code.** I broke the tutorial mod five ways on 2.1.302 to see what each check says:

| What I broke | `claude plugin validate` said |
|---|---|
| Misspelled event, `on('tool.calls', …)` | `"tool.calls" is not an event; $ is always spelled $.noun.event(...) at the call site, on is always on("<event>", hook), and next.to always next.to(e, "<tier>")` |
| Removed `"modules"` from `hooks.json` | ``hooks.json must have `hooks` (the hook matchers) or `modules` (hooks modules), or both`` |
| Named the plugin `claude-tally` | `Plugin name "claude-tally" is reserved: it passes as one of Anthropic's own. A third party's plugin name cannot start with "claude-", "anthropic-", "anthropics-", or "cc-plugin-"…` |
| Wrote `const ui = $.ui` | `$.ui is used as a value (a noun of $ bound, passed or read)` |
| Threw an error at load | `✔ Validation passed` |

The last row is the one to remember. Validate passed a mod that crashes the moment it loads; `claude plugin test` caught it:

```text
(fail) /tally reports the tool calls the mod has seen [97.34ms]
  HooksError: first-mod: hooks module did not load: Error: boom at load
```

### A broken mod's command goes to Claude as a prompt

The headless run of that broken mod showed a trap. stderr printed `first-mod: hooks module did not load: Error: boom at load`, and then, because `/tally` no longer existed, Claude Code sent `/tally` to Claude as an ordinary prompt. Claude looked around the folder and answered with a tally it worked out by hand. That turn used my subscription's usage, and an unattended script would have read Claude's answer as the command's output. Check stderr, or make the command's text something your script can recognize.

### Other messages you'll see

| Message | What it means |
|---|---|
| `hooks module did not load: <reason>` | The module couldn't load, usually because its top-level code threw. Fix the error named; if it ends `the version loaded before is unloaded`, run `/reload-plugins` after fixing |
| `hooks module <name> not loaded: disableAllHooks in managed settings` | Your organization turned off mods from installed plugins (a debug log line, per Anthropic's troubleshooting page) |
| `installed plugins that are not managed load no hooks module in this mode (--bare)` | You started with `--bare` |
| `<event> hook skipped: threw Error: …` | One hook failed, timed out or returned the wrong shape; the rest of the mod runs |
| `registered /tally but no command.run hook answered it` | The command exists but no hook answered: wrong matcher, or the hook returned `next(e)` |
| `was unloaded: it crashed the hooks worker` | A hook blocked the shared worker thread, for example with a loop that never awaits |
| No mod loads in a new folder | You haven't accepted that folder's trust prompt; start `claude` there once |
| Your edits don't take effect | You're editing an installed copy; Claude Code runs the cached version. Develop with `--plugin-dir` |

To see whether mods can load at all on your machine, run `claude plugin test` in a folder with no mod in it. On mine it printed `no hooks module to load; there is no hooks/hooks.json naming one in "modules"`, which, per Anthropic's [troubleshooting page](https://code.claude.com/docs/en/plugins/mods/troubleshoot), means mods can load. `hooks modules are turned off here` means a setting blocks them, and `the rollout switch served off` means Anthropic has turned installed mods off remotely. For everything else, start Claude Code with `claude --debug-file ./mod-debug.log --plugin-dir ./your-mod` and search the log for your mod's name. If the error isn't about a mod at all, the [Claude Code troubleshooting hub](/blog/claude-code-troubleshooting) lists the rest.

## Do mods work in VS Code, the Desktop app and claude -p?

**Mod hooks run in the terminal CLI, the Claude Desktop Code tab, the VS Code extension, `claude -p`, the Agent SDK and cloud sessions, but not in a WSL session of the Desktop app. What a mod draws appears only in the CLI, the Desktop Code tab, and VS Code from extension 2.1.299.**

| Where you run Claude Code | Hooks run | Drawings appear |
|---|---|---|
| `claude` in a terminal, including editor terminals and JetBrains | Yes | Yes |
| Claude Desktop, Code tab | Yes | Yes, except terminal-only elements |
| Claude Desktop, WSL session | No (plugins aren't available there) | No |
| VS Code extension chat panel | Yes | Yes, from extension 2.1.299 (2.1.304 for sessions that skip feature flags, such as Bedrock) |
| `claude -p` and the Agent SDK | Yes | No |
| Cloud sessions | Yes, if the plugin reaches the session | No |

Hooks also run whichever provider serves the model, including Amazon Bedrock, Google Cloud's Agent Platform (Vertex AI) and Microsoft Foundry.

## How do I turn Claude Code mods off?

**One mod: disable or uninstall it in the Installed tab of `/plugin`. Every installed mod for one session: start with `claude --safe-mode`. Every mod you installed, in every session: set `"disableAllHooks": true` in `~/.claude/settings.json`.** That last one also stops your settings hooks and custom status line. None of the three stops built-in mods. If you set `CLAUDE_CODE_ENABLE_FUNCTION_HOOKS` during early access, remove it: 2.1.287 and later ignore it, so setting it to `0` doesn't keep mods off. My [Claude Code settings reference](https://tools.its-tahir.com/claude-code-settings) lists where each settings file lives.

## Claude Code versions that changed mods

| Version | Change |
|---|---|
| 2.1.287 (1 Oct 2026) | "Added Claude Mods: plugins may now modify deeper behavior"; built-in "You should know" mod |
| 2.1.288 (2 Oct) | `$.ui.selection()`; fixed `claude plugin test` reporting mods off from a stale saved setting |
| 2.1.289 (3 Oct) | Fixed installed mods not loading in the first session after an upgrade; a drawing error no longer ends the session |
| 2.1.290 (5 Oct) | `claude plugin validate` lists each gating hook with whether it has a `.catch`; mods work for gateway users with no Anthropic account |
| 2.1.292 (6 Oct) | `prompt.autocomplete` event; prompt caching for `$.model.complete` |
| 2.1.299 (14 Oct) | VS Code chat panel draws what mods draw |
| 2.1.323 (12 Nov) | Each mod gets its own row above the prompt instead of sharing one drawing |
| 2.1.326 (16 Nov) | Mods can use Bash, Read and other tools through `$.tool.call` in Code Mode (an experimental opt-in from 2.1.323 where Claude writes JavaScript to call its tools); edits in a session's mods folder ask more often |

Versions and descriptions are from the [changelog](https://github.com/anthropics/claude-code/blob/main/CHANGELOG.md) and Anthropic's mods docs; dates are npm publish dates. The events and methods still change between releases, so Anthropic's docs say to trust the type files Claude Code writes into your mod's `.claude-plugin/types/` folder over any page, this one included.

**Key takeaways**

- A Claude Code mod is a plugin whose JavaScript or TypeScript runs inside Claude Code; each hook can observe, rewrite or answer an event.
- Mods can draw panes and bands, add instant /commands and hold or change tool calls. They arrived in Claude Code 2.1.287 on 1 October 2026.
- Install with /plugin install name@marketplace, or try one for a session with claude --plugin-dir ./the-mod. Anthropic's samples are token-weather, blast-radius and replay-theater.
- A mod runs with your permissions and isn't sandboxed. Run claude plugin validate before installing and read its hooks and calls lines.
- validate only reads the code: on 2.1.302 it passed a mod that throws at load. claude plugin test caught it.
- When a mod's module fails, its /command reaches Claude as an ordinary prompt, which costs usage and can look like a real answer.

## FAQ

## Related

- [Claude Code not working? 30+ errors and how to fix them](/blog/claude-code-troubleshooting)
- [Claude Code auto mode](/blog/claude-code-auto-mode)
- [MCP server not showing up in Claude Code](/blog/mcp-server-not-showing-up-in-claude-code)
- [Claude Code sandbox](/blog/claude-code-sandbox)
- [Claude Code vs Cursor: how each loads project instructions](/blog/claude-code-vs-cursor-context-management)

## FAQ

### What are Claude Code mods?

A mod is a Claude Code plugin whose JavaScript or TypeScript runs inside Claude Code. Claude Code calls the mod's functions, called hooks, when an event happens, such as a tool call, a submitted prompt or part of the interface being drawn, and each hook can watch the event, change it, or answer it itself. That lets a mod draw panes and bands, add /commands that run instantly, and hold or rewrite tool calls. Mods arrived in Claude Code 2.1.287 on 1 October 2026.

### How do I install a Claude Code mod?

A mod installs like any plugin, from a marketplace: run /plugin install name@marketplace in a session, or claude plugin install name@marketplace in your shell, then /reload-plugins if a session is already open. To try a mod without installing it, clone it and start Claude Code with claude --plugin-dir ./the-mod. Run /plugin and look for the 'mods active' line to confirm it loaded.

### Are there official Claude Code mod examples?

Yes. Anthropic shares three sample mods in the claude-code/mods folder of its claude-code-playground repository: token-weather (a context-window forecast above the prompt), blast-radius (holds risky shell commands such as rm -rf and shows what they would change) and replay-theater (a /replay command for the last turn's edits). The source of built-in mods such as /diff and AGENTS.md loading is in the mods folder of the anthropics/claude-code repository.

### Are Claude Code mods safe?

Only as safe as their author. A mod runs with your permissions and isn't sandboxed: it can read and write your files, read API keys in your environment and settings, see every prompt and tool call, approve tool calls before you're asked and spend your usage. Before installing one, run claude plugin validate on its folder; the hooks and calls lines list what it handles and what it asks Claude Code to do, without running it.

### Why does my Claude Code mod do nothing?

Claude Code skips a mod that fails, so a broken mod looks like one that does nothing. Run claude plugin validate on its folder to catch a misspelled event, a missing modules key or a reserved name, then run claude plugin test, because validate only reads the code and passed a mod that throws when it loads. In a claude -p run the reason goes to stderr, such as 'hooks module did not load: Error: boom at load'.

### Do Claude Code mods work in VS Code and the Desktop app?

Yes. Mods run in the CLI, the Code tab of Claude Desktop and the VS Code extension. What a mod draws appears in the VS Code chat panel from extension version 2.1.299. In claude -p and the Agent SDK a mod's hooks run but nothing it draws appears, and in a WSL session of the Desktop app mods don't run at all.

### What is the difference between a mod and a hook in Claude Code?

A settings hook is a shell command, HTTP request or prompt you configure in settings.json; it can allow, block or log an event. A mod is code that runs inside Claude Code: it can do the same and also draw in the interface, add instant commands and rewrite events. Anthropic's docs call a mod's handlers hooks too, and the settings-file kind 'settings hooks'.

### How do I turn off Claude Code mods?

Disable one mod in the Installed tab of /plugin. To skip every installed mod for one session, start Claude Code with --safe-mode. To stop every mod you installed in every session, set "disableAllHooks": true in ~/.claude/settings.json, which also stops your settings hooks and custom status line. Built-in mods keep running in all three cases.

## Sources

- [Mods overview (Claude Code docs)](https://code.claude.com/docs/en/plugins/mods/overview)
- [Create a mod (Claude Code docs)](https://code.claude.com/docs/en/plugins/mods/create)
- [Troubleshoot a mod (Claude Code docs)](https://code.claude.com/docs/en/plugins/mods/troubleshoot)
- [Mods reference (Claude Code docs)](https://code.claude.com/docs/en/plugins/mods/reference)
- [Sample mods: token-weather, blast-radius, replay-theater (anthropics/claude-code-playground)](https://github.com/anthropics/claude-code-playground/tree/main/claude-code/mods)
- [Source of built-in mods: diff, agents-md, sec-default, telemetry (anthropics/claude-code)](https://github.com/anthropics/claude-code/tree/main/mods)
- [Claude Code changelog: 'Added Claude Mods' (2.1.287) and later mod fixes](https://github.com/anthropics/claude-code/blob/main/CHANGELOG.md)
- [@anthropic-ai/claude-code release dates (npm)](https://www.npmjs.com/package/@anthropic-ai/claude-code)
