Claude Code Mods: How to Rewire Your Coding Agent With Tiny TypeScript Hooks

On October 1, 2026, Anthropic shipped something that quietly changed what Claude Code is. It wasn't a new model. It was mods: small TypeScript functions that run inside Claude Code and hook into the events the agent already fires — a prompt being submitted, a tool call about to run, a piece of the screen being drawn.

Until then, customizing Claude Code meant a settings file, a slash command, or a shell hook that watched from the outside. Mods move the customization inside the process. That one change is why developers are suddenly talking about Claude Code as a platform they can shape, not just a tool they use.

What a mod actually is

A mod is a plugin whose code registers event handlers. When Claude Code is about to do something — send your prompt to the model, run a Bash command, ask for permission, render a panel — it calls each registered handler first. The handler can watch, rewrite, block, or take over.

That makes mods different from the customization options most Claude Code users already know:

• Skills give Claude knowledge: instructions and context it reads when relevant.
• Slash commands give you shortcuts: canned prompts you trigger by hand.
• Settings hooks run shell scripts around events, but from outside the process.
• Mods run inside the process, so they can do things the others can't: rewrite a prompt before it leaves your machine, approve or deny a tool call, redact a secret from tool output before Claude reads it, and draw new interface elements — panes, buttons, text fields.

Mods ship inside plugins, so you install and share them the same way you install any Claude Code plugin. They work in the terminal from Claude Code v2.1.287 and in the Desktop app's Code tab from v2.1.286, and they are switched on by default from those versions. If a mod does nothing on your machine, the first thing to check is your version.

Three things mods unlock in practice

1. Fix your prompts before the model ever sees them.

Most of us paste a brain dump into the agent and hope for the best. A mod can intercept the submitted prompt, restructure it into goal, constraints, and acceptance criteria, and show you the rewritten version before it goes to the model. You get the speed of dumping your thoughts and the quality of a well-written brief.

2. Put guardrails around what the agent can touch.

A mod can watch tool calls and stop risky ones before they run, or scrub secrets out of tool output. One of the examples Anthropic's community built early on hides values from .env files while still letting Claude use them safely. Think of it as a bouncer for your agent: it sees every request at the door.

3. Reshape the interface around your workflow.

Because a mod can draw in Claude Code's UI, it can add a panel showing your current task list, a button that runs your most-used workflow, or a dashboard view of the day's work. This is the use case that surprises people most — you are no longer stuck with the layout Anthropic shipped.

None of this requires forking Claude Code or waiting for a feature request. If you can describe the behavior you want, you can often ask Claude Code to build the mod for you, and it will write the TypeScript, install it, and hot-reload it in the session.

Try one before you build one

The fastest way to understand mods is to install a trusted sample and poke at it:

1. Check your version first. In the terminal, run claude --version and confirm you are on 2.1.287 or later. In the Desktop app, mods work from 2.1.286 in the Code tab.
2. Run /plugin and look under Built-in to see the mods Anthropic ships.
3. Anthropic's sample mods live in the claude-code-playground repository on GitHub — a good starting set to read before you install anything from a third party.
4. The community catalogue grew fast: by October 9, 2026 it listed almost 3,000 public mods. Treat that number as a sign of momentum, not a recommendation — popularity is not a safety check.

Build your first mod in an afternoon

A good first mod is small and boring: a prompt rewriter. The sketch below shows the shape of one — a mod that notices a long, unstructured prompt and restructures it into a brief. Read it as an illustration of the pattern, not a copy-paste recipe: Anthropic warns the mods API may still change between releases, so check the current docs at code.claude.com/docs before you build on any detail.

// A mod is a small function that hooks into Claude Code's events.
// This sketch shows the pattern: intercept the prompt, rewrite it,
// and let the user see the result before it reaches the model.
import type { Mod } from "@anthropic/claude-code-mods";

const briefRewriter: Mod = {
  // Runs when a prompt is submitted, before it reaches the model.
  onPromptSubmit(prompt) {
    if (prompt.length < 200) return prompt; // short prompts pass through

    return [
      "Rewrite the following brain dump as a structured brief",
      "with Goal, Constraints, and Acceptance Criteria,",
      "then answer the brief — not the raw dump:",
      "",
      prompt,
    ].join("\n");
  },
};

export default briefRewriter;

The interesting part isn't the code — it's the workflow it creates. You keep typing the way you already type, and the agent keeps receiving the kind of input it works best with. Once that pattern clicks, the next mod usually writes itself: a hook that blocks rm -rf outside the project directory, one that appends your team's style guide to every prompt, one that logs every model call to a local file so you can see where your credits actually go.

The one rule you cannot skip

Here is the part every mods tutorial should lead with, and most bury: mods are not sandboxed.

A mod is code that runs with your permissions, inside Claude Code's own process. Its file operations don't trigger tool permission prompts, and a process it starts runs outside Claude Code's sandbox. Anthropic says it plainly, and the guidance is simple: install mods only from sources you trust, the same way you would install any code on your machine.

On Team and Enterprise plans, a built-in sec-default mod loads ahead of every user mod and protects what your organization manages — for example, stopping a user-installed mod from overriding permission deny rules. If you manage a team, that is the first thing to verify before anyone on your team starts collecting mods.

Practical vetting, before you install anything:

• Read the mod's source. A mod is usually a handful of TypeScript files — if you can't find the source, don't install it.
• Check what it hooks into. A prompt rewriter has no business touching your filesystem.
• Prefer mods from authors or organizations you already trust, and pin a version instead of tracking the latest commit.

Why this matters beyond Claude Code

Mods are part of a bigger shift. Coding agents started as chat boxes that wrote code. Then they became tools with memory, skills, and plugins. Mods take the next step: the agent becomes a platform, and the interface, the guardrails, and the behavior are all things you can program.

That is exciting, and it is also a responsibility. The developers who get the most out of mods won't be the ones who install the most of them — they'll be the ones who install a few, read them, and build the one that fixes their own most annoying workflow.

Start with the prompt rewriter. Read one sample mod end to end. And before you install anything from a stranger, remember the rule: a mod runs as you, with your permissions, on your machine. Treat it like code — because it is.

— Written by Davis George · zhuan.xyz