Claude Code Mods - DeveloPassion

# Claude Code Mods Claude Code mods are [[Claude Code Plugins|plugins]] made of [[JavaScript]] or [[TypeScript]] event handlers that [[Claude Code]] calls inside its own process: when a tool call happens, when you submit a prompt, when part of the UI gets drawn. Each handler can watch the event, change it, or take over. Where [[Claude Code Hooks|settings hooks]] run a shell command at a lifecycle event, a mod runs in the process, gets a typed `

object describing what it may do, and calls `next()` to continue the chain, in the style of Express or Koa middleware. Claude Code's UI is [[React]], so a mod can also **draw UI**. Before mods, you could change what Claude Code knows (skills, CLAUDE.md) and what it may do (permissions, hooks). Mods also change how it works and how it looks. You don't have to learn the API first: you can ask Claude to write the mod for you. Early access was announced by [[Boris Cherny]] on 2026-09-14: "Claude Mods are landing now. Someone already built a Tetris-in-Claude mod 🤯". The public launch followed on 2026-10-01, when @ClaudeDevs posted: "You can now mod Claude Code: Change how it behaves, Customize the UI, Swap in your own features". My take on the launch is in [[2026-10-04 Claude Code Mods - Claude Code is now programmable, and mods aren't sandboxed]]. ## Where it stands (October 2026) - **On by default** since Claude Code v2.1.287, the version given by the docs and the launch guide. [[Morgan Lunt]] (product at Anthropic) wrote "2.1.286+" on LinkedIn; this note follows the docs - The early access flag `CLAUDE_CODE_ENABLE_FUNCTION_HOOKS` is now ignored - `/plugin` shows how many mods are running ("1 mod active · first-mod") - To turn mods off: disable the plugin in `/plugin`, start the session with `--safe-mode`, or set `"disableAllHooks": true`. None of these stop the built-in mods (`--bare` doesn't either) - Naming: the docs call a mod's handler a "hook", and the kind you configure in a settings file a "settings hook". Morgan Lunt: mods are "a new type of hook that listens to CC engine events. We were going to call them function hooks" - The mods README still warns that the "API may change between releases without notice". Type declarations are generated for each release ## Early access (September 2026) - The proposal was posted for community feedback on 2026-09-03 as GitHub issue #91870, "Mods: make Claude 10x more extensible", with a technical architecture PDF and short demo videos - The 2026-09-09 community update committed to shipping "on the scale of weeks", named the product **Claude Mods**, and kept *function hook* as the engineering term for the primitive underneath. A mod is a plugin that uses function hooks - Source listings for the first three built-in mods were published under `mods/` in the claude-code repo. Anthropic intended to migrate more existing features into mod form over time (several have moved since, see [[#Built-in mods]]) - Testing it required `CLAUDE_CODE_ENABLE_FUNCTION_HOOKS=1 claude` (v2.1.267+). Semantics were mostly settled; the interface was still moving. Since the launch, that variable does nothing ## What mods can do According to the official docs, mods cover what settings hooks, skills, status lines and MCP servers can't: - Draw an interactive interface: a pane beside the transcript, a band above the prompt, tabs, buttons, text fields - Redraw Claude Code's own UI: tool call rows, the spinner, the AskUserQuestion dialog - Step into a tool call or a request: hold a tool call while asking you something, answer it without running the tool, or send a request to a different model - Add slash commands that answer instantly: a `/command` that runs your own function with no Claude turn, even while Claude is working - Share data between hooks ### Observe, Rewrite, Answer Every hook receives `($, e, next)`. What it does with `next` decides its role: - Observe: call `next(e)`, then inspect the result. Record every file edit, or take a reading after each turn - Rewrite: change the event before calling `next`, so the rest of the chain sees your version. Rewrite a prompt before it hits the model, or change a tool call - Answer: return without calling `next`. Refuse a tool call, or serve a command yourself ### What a function hook can do (early access demos) From the demo series: 1. **A hook as a function**: TypeScript with full type definitions and LSP support instead of a shell script 2. **A hook that says no**: restrict behaviour for safety and control, as with classic hooks 3. **Plugins can draw**: hook onto components, modify their props, or wrap their rendered nodes 4. **Admin control as a hook**: an admin can remove affordances from `

so every plugin further down the chain loses that side effect. Hooks wrap each other in registration order Safety comes from **side-effect tracking over the parameterized `

object**: a hook can only do what its `

exposes, and a hook above you can shrink what your `

exposes. Composition follows registration order with a `next` continuation. The author's own summary: "an effect-parameterized endomorphic continuation model for plugins." The `

sigil is a jQuery homage and, per the author, "isn't negotiable". ## How a mod is built A mod is a standard plugin with three files: - `.claude-plugin/plugin.json`: the plugin manifest - `hooks/hooks.json`: points to the modules - `hooks/register.js` (or `.ts`): exports `register(on, options)` Inside `register`, you subscribe to events. `on('tool.call', async ($, e, next) => ...)` intercepts tool calls. `on('ui.render', { component: 'Spinner' }, ...)` redraws a component, and `$.ui.invalidate` asks for a redraw. A few details from the launch guide on claude.dev: - `$.state` holds reactive state for the length of a session, and it survives a hot reload. Read it with `$.state.get` inside a render and the UI redraws by itself on every `$.state.set`. For data that must outlive the session, use `$.store` (see [[#Keeping state]]) - A hook has 10 seconds to run. Time spent inside `

calls doesn't count - Types live in `types/index.d.ts` (the `PluginState` interface, for instance), regenerated for each release - Everything a mod does outside its own code goes through the `

API. That's how Claude Code can list what a mod does before you install it The dev loop: - `claude --plugin-dir ./token-weather` loads your mod with hot reload - `claude plugin validate` checks it; `claude plugin test` runs its tests (`claude-code/testing` gives you `describe`, `expect`, `mock`, `test`) - Share it: push it to GitHub with a marketplace file, then `/plugin marketplace add your-org/my-mods`, `/plugin install token-weather@my-mods`, `/reload-plugins` - Publish it to the Claude directory at claude.ai/directory/manage. See [[Claude Marketplace]] for how the directory, plugin marketplaces and Anthropic's storefront fit together ### Or just ask Claude to mod itself Anthropic promotes this route. Ask Claude Code for the mod you want, and it writes the mod, installs it and hot reloads it in the same session (Morgan Lunt). A built-in skill (`plugin-authoring`, shipped by the `cc-plugin-plugin-authoring` built-in plugin) teaches Claude the mod API; you can also load it yourself with `/plugin-authoring`. Per the docs, Claude writes the mod under `~/.claude/dev-mods/<session id>/<mod name>/`. When it saves the first file, Claude Code asks whether to enable hot reloading for the session; after that, the mod reloads at the end of each turn that changes it. A mod written this way only loads in the session that made it, and the folder gets deleted after `cleanupPeriodDays`. To keep it, copy the directory somewhere of your own and load it with `claude --plugin-dir <dir>`, or put it in a marketplace. It doesn't load in `claude -p`, in `dontAsk` mode, in an untrusted workspace, or with `--safe-mode`, `--bare` or `disableAllHooks`. ## Events Events are grouped by what they concern (full tables in the mods reference): - **Tools**: `tool.call` (about to run: pass, `{ deny }` or answer with `{ result }`), `tool.check` (the allow/ask/deny decision, after the rules and PreToolUse hooks), `tool.describe` (rewrite a tool's description, or defer it behind tool search) - **Prompts and what Claude reads**: `prompt.submit`, `prompt.fill`, `prompt.suggest`, `prompt.edit`, `prompt.compose` and `prompt.section` (the system prompt, section by section), `prompt.context`, `prompt.attachment` (reminders Claude Code adds), `prompt.mention` (@-mentioned files), `skill.prompt` (a skill's text as Claude gets it), `attribution.text` (commit and PR attribution) - **Commands and configuration**: `command.run`, `command.describe`, `config.set`, `config.describe` - **Turns**: `turn.start`, `turn.step` (each request to the model; you can swap the model or the effort per request), `turn.complete` - **Session**: `session.start`, `session.end`, `session.compact` (can skip a compaction), `session.receive` / `session.send` (messages between sessions and agents), `session.append`, `session.attach` / `session.detach`, `session.measure` - **Subagents**: `agent.offer` (hide a subagent type from Claude), `agent.spawn` (pick its model or refuse it) - **Interface**: `ui.render`, `ui.press`, `ui.input`, `ui.select`, `ui.focus`, `ui.scroll`, `ui.close`, `ui.message`, `ui.fault` - **Other mods**: `plugin.register` (refuse a mod based on what it uses), `engine.create` (change the `

API a mod receives) - **Telemetry**: `telemetry.log`, `telemetry.mark` - **Settings hook events**: every [[Claude Code Hooks|settings hook]] event is also available as `classic.<Event>` (`classic.Stop`, `classic.PostToolUse`…), with the hook's stdin JSON as `e` - **Mods API calls**: every `

method is itself an event (`fs.read`, `model.complete`, `ui.open`), so a mod earlier in the chain can observe, rewrite or refuse the calls of the mods after it. That's how an organization restricts what mods reach The chain order: the built-in guard and the organization's `prependPlugins` first, then the mods you install, then `appendPlugins`, then the other built-ins. The first mod is the outermost one: it sees the event before the others and the result after them. `PreToolUse` hooks from managed settings run before the first mod; the other `PreToolUse` hooks run after the last mod calls `next`. A hook that throws or times out before calling `next` is skipped; add a `.catch` handler to make a guard fail closed. ## The `

API Every hook gets the API as `

. The module itself has no Node.js APIs, no timers and no network or file access of its own (standard web APIs such as `URL`, `TextEncoder` and `crypto.subtle` are there). Namespaces: | Namespace | What it does | |---|---| | `$.ui` | Panes, redraws, toasts, the status line under the prompt (`status`), dim transcript lines (`log`), notices, questions (`ask`), the clipboard (`copy`), selection, `blit` for animated grids | | `$.command` | Register, run and list slash commands | | `$.tool` | Register tools Claude can call, call or check tools, list them | | `$.agent` | Register and spawn subagents, list them with their status | | `$.model` | `complete` (one prompt to a model, no history), `fork` (one question over the current conversation, mostly from the prompt cache), `classify` | | `$.prompt` | `submit` (start a turn from a background job), `read`, `fill`, `suggest`, `compose` | | `$.turn` | `abort` | | `$.session` | Transcript (`messages`), working directory, model, `usage()` (context window, plan limits, cost), `send` to other sessions, `compact` | | `$.config`, `$.settings`, `$.env` | `/config` rows, read settings and managed policy, environment variables | | `$.fs`, `$.process`, `$.http`, `$.mcp` | Files, processes (argument lists, no shell), `fetch`, and calls to connected MCP servers | | `$.store`, `$.state` | Persistent key-value store, and reactive session state | | `$.clock` | `now`, `sleep`, `after`, `every` (instead of `setTimeout` and `setInterval`) | | `$.audio`, `$.telemetry`, `$.plugin` | Play or speak, telemetry records, the plugin's own name and directory | `$.model` calls run on your plan or API key. ## Commands and tools A mod registers both in a `session.start` hook, so they exist from the first turn: - **A command is for you.** `$.command.register({ name, description, argumentHint })`, then handle `command.run` for that name. The returned `{ text }` lands in the transcript and Claude reads it; return `{}` to print nothing (e.g. a command that only opens a pane). Add `immediate: true` and the command runs while Claude is working. Registering a name a built-in command uses throws - **A tool is for Claude.** `$.tool.register({ name, description, inputSchema })`. Claude sees it as `mcp__<plugin name>__<tool name>`, the same naming as an [[Claude Code MCP Integration|MCP tool]], and the mod answers it in a `tool.call` hook filtered on that full name. With tool search on, the tool can be deferred; `isDeferred: false` (v2.1.293+) loads it upfront With a registered tool, Claude reports what it did through a structured call that writes straight into the mod's own state, so the mod doesn't have to parse Claude's prose. My [[2026-10-09 Session Flags - the first Claude Code mod I'm building|session flags mod]] uses this design. ## Panes, the band and the keyboard - A **pane** is a sidebar beside the transcript in a wide fullscreen terminal, or a framed region above the prompt otherwise. It only appears when the mod calls `$.ui.open({ id, title })`. A pane the mod opens by itself (from a timer or a `turn.start` hook) waits for a terminal of at least 144 columns, or 110 once you've opened it yourself - The **band** is the shared strip above the prompt (`ui.render` with `{ component: 'AbovePrompt' }`) - A mod can also redraw Claude Code's own render sites: the spinner, tool call rows, the `AskUserQuestion` dialog. Not the permission prompt - Your mod never reads the keyboard. Keys reach its controls only while its pane or band has focus, with one exception: a button in the band with a digit `hotkey` fires when you type that digit alone in an empty prompt and pause - Default keys: `Ctrl+X Tab` moves focus into the band, then each open pane, then back to the prompt. `Ctrl+X Ctrl+A` collapses or expands the band. `Ctrl+X X` closes a pane. `Esc` returns to the prompt. All of these can be rebound in `keybindings.json` ## Keeping state | | Lasts until | Use it for | |---|---|---| | Variables in the module | The module reloads | Data shared between the mod's hooks | | `$.state` | The session ends, or `/clear`, `/resume` or `/branch` | Values a drawing reads; writing one redraws the sites that read it | | `$.store` | The mod deletes it, or nobody touches it for `cleanupPeriodDays` | Settings and history. A JSON file per plugin under `~/.claude/plugins/store/`, 4 MiB max, shared by every session on the machine | `$.store` writes aren't atomic across sessions: two sessions doing get-then-set race, and the second write wins. ## Testing and debugging - `claude plugin test` runs `*.test.ts` files with the test kit from `claude-code/testing` (`test`, `expect`, stubs). A test fires events and stubs what Claude Code would answer, with no session, sign-in or network, and exits 1 on failure, so it works in CI. One test gets 5 seconds by default - `claude plugin validate` lists the `hooks:` and `calls:` of a mod without running it - Develop with `--plugin-dir` against your working copy. An installed plugin is cached by version, so edits don't reach it until you bump the version and reinstall. `CLAUDE_CODE_PLUGIN_DIRS` does the same as `--plugin-dir` for apps where you can't pass a flag - The troubleshooting page lists the log lines a mod produces (`hook skipped`, `hooks module did not load`, `threw while drawn`…) and how to read the debug log - The TypeScript declarations (`mods/types/claude-code.d.ts` in the claude-code repo) are the complete reference. The GitHub copy can lag your installed version ## Limits From the reference: a hook gets 10 seconds of its own execution time per event (50 ms for `prompt.edit`; time inside `next` and `

calls doesn't count, except `$.clock.sleep`), `$.process.run` times out after 30 seconds by default (10 minutes max), `$.model.complete` defaults to 1,024 output tokens, `$.fs` reads and writes cap at 4 MiB per file, redraws are throttled to 10 per second (30 for the visible pane in the terminal), and toasts show for 4 seconds. ## Where mods run | Where | Hooks | UI | |---|---|---| | CLI (including [[Claude Code IDE Integration|editor terminals]] and JetBrains) | Yes | Yes | | Desktop app, Code tab (not WSL) | Yes | Yes | | VS Code extension chat panel | Yes | No | | `claude -p` and the [[Claude Code SDK|Agent SDK]] | Yes | No | | [[Claude Code Remote Control\|Remote Control]] | Yes, on your local machine | | | [[Claude Code Web|Cloud sessions]] | Yes | No | No mobile support. Commenters also noticed the limits in the VS Code and Cursor extensions (hooks, no UI). ## Built-in mods Claude Code now ships some of its own features as mods. You'll find them under `/plugin` → Installed → Built-in: - `cc-plugin-agents-md`: loads `AGENTS.md` (see [[AGENTS.md (File Convention)]]) - `cc-plugin-diff`: the `/diff` pane. Turn it off, or swap in your own - `cc-plugin-plugin-authoring`: the skill for writing mods - `cc-plugin-sec-default`: the security guard (see [[#Security model]]) - `cc-plugin-telemetry` - `cc-plugin-you-should-know`: a side agent for longer tasks. It scans Claude's output for important information you might miss and shows a note above the prompt. Disabled by default; turn it on with `/plugin enable cc-plugin-you-should-know@builtin` (announced on 2026-10-02) Morgan Lunt says more built-ins will move to mods, so Claude Code can shrink to a small core and you choose (or replace) everything around it. The sources for the agents and `/diff` mods are in the claude-code repo. ## Sample mods Anthropic's samples live in `anthropics/claude-code-playground` (folder `claude-code/mods`): - Token Weather: a context "forecast" with weather icons, a percentage, the token count and a sparkline. About 80 lines - Blast Radius: previews risky commands like `rm -rf` or `git reset` before they run - Replay Theater: steps through the file edits of completed turns ## Community mods - [prismantis](https://github.com/NahumLitvin/prismantis): themeable replies, tables and mermaid diagrams, with 15 themes - [claude-markdown-mod](https://github.com/deepskyblue86/claude-markdown-mod): one of the two community mods [[Addy Osmani]] picked in his launch post - Morgan Lunt's code modernization plugin uses a mod to draw a live status pane. A code map lights up as agents touch modules, next to the plan phases, the modules already proven, and what still needs a human - Someone got Doom running inside Claude Code ### First community mod: cc-arcade The Tetris demo from early access is [cc-arcade](https://github.com/sezaakgun/cc-arcade): Tetris and seven other games rendered above the prompt, playable while Claude works, using zero tokens. It uses these parts of the API: - `ui.render` on the `AbovePrompt` surface, one `Client` module per game board - `turn.complete` pauses the game when Claude finishes - `tool.call` feeds a virtual pet - `$.store` keeps scores between sessions (`$.state` is the reactive, per-session counterpart; see [[#Keeping state]]) The author lists these friction points: an `h` local-variable rule in surface modules, `Client` module paths must be string literals, and the render band is about half the terminal, redrawing roughly ten times a second. None of it was documented at the time. ## Security model From the launch guide: "A mod is code that runs inside Claude Code on your machine, with the same access Claude Code has, and it's written by its publisher, not Anthropic." Mods are **not sandboxed**. Claude Code's sandbox isolates the Bash commands Claude runs; mod processes run outside of it. A mod can: - Read and write files, start programs, use the network, and read secrets (environment variables, settings) - See every prompt and tool call, and rewrite them - Submit a prompt as if you typed it, and message other sessions - Approve tool calls before you're even asked - Spend your usage by calling a model It can't change how the permission prompt looks. Before you install a shared mod, run `claude plugin validate ./some-mod`. It lists the mod's `hooks:` and `calls:` lines without running it. Read the code as well. Rules from the admin docs ([[Claude Code Permissions]]): - Deny rules win over user mods (unless `allowModsToOverrideDenyRules` is set). But a mod's own `$.fs` and `$.process` calls bypass them. Deny `Read(.env)`, and a mod can still `$.fs.read` it - User mods can approve `ask` calls and bypass non-managed PreToolUse hooks. In [[Claude Code Auto Mode|auto mode]], a call that a mod approved skips the classifier - If the hooks worker crashes three times, every non-built-in mod unloads For teams: - On machines with managed settings, and for Team and Enterprise users, the built-in guard `sec-default@builtin` loads ahead of every user mod. It can't be disabled. It protects managed hooks, the system prompt, the managed CLAUDE.md, settings and managed MCP tools, and it fails closed - Policies: `allowManagedModsOnly` (set in `pluginConfigs` → `cc-plugin-sec-default@builtin` → options), `allowManagedHooksOnly`, `disableAllHooks`, `disableSideloadFlags` (rejects `--plugin-dir`, `--plugin-url`, mods Claude writes in the session, `--agents` and `--mcp-config`), `strictKnownMarketplaces`, and `prependPlugins` / `appendPlugins` for org policy mods - A policy mod can hook `plugin.register` and refuse other mods based on what they call (`e.uses.calls`, e.g. `process.run`) - Admins can choose one of three stances: mods from approved marketplaces only, org-deployed mods only, or no mods at all - Per a comment in Morgan Lunt's thread, Claude Code reads `AGENTS.md`, plus agents and skills from `.agents/` on top of `.claude/`, but not settings, permissions, hooks or MCP config from there, on purpose ## Mods vs settings hooks, skills and MCP From the docs: | | What it is | What it changes | Can draw | Pick it when | |---|---|---|---|---| | **Mod** | JS/TS functions in a plugin, in Claude Code's process | Tool calls, prompts, commands, turns, UI | Yes | You want a pane, a band, a custom command, or to rewrite an event | | **[[Claude Code Hooks\|Settings hook]]** | Shell command, HTTP call or prompt on a lifecycle event (script + `settings.json`) | Block, allow, log | No | You need a simple gate or a log | | **[[Claude Code Skills\|Skill]]** | `SKILL.md` instructions | What Claude knows and does | No | You keep pasting the same instructions | | **[[Claude Code MCP Integration\|MCP server]]** | External process exposing tools | Which tools Claude has | No | Claude needs an external system | A single plugin can hold all four. For the wider picture (CLAUDE.md, subagents, status lines, plugins), see [[Claude Code Extension Points]]. ## Critiques - Composition: stack a prompt rewrite, a tool intercept, another plugin and a UI mod, let Claude generate and hot-load mods on its own, and it's unclear how you test what they do together (Jacob A., in Morgan Lunt's thread) - In a hook chain, the order defines what the system does, so you need provenance and debugging: which hooks ran, in which order, and who changed what (comments under Addy Osmani's post) - Read the code of a shared mod before you install it, the same way you'd vet an npm package - No mobile support, and no UI in the VS Code and Cursor extensions ## What people said - [[Boris Cherny]]: "Mods are absolutely insane. You can now customize Claude to work and look the way you want by just prompting it. Each person works differently, so there's no reason why everyone should have an identical Claude experience. Make Claude your own, and share mods as plugins so others can try your mods too." - [[Addy Osmani]]: "Customize how Claude Code looks and works just by prompting it." And: "You don't need to know the API. Prompt Claude to build one then share it as a plugin." - [[Lydia Hallie]], in her video walkthrough: "They're really just plugins with a few special functions that let your code run inside Claude Code, like middleware. (don't worry, you can just ask Claude to write them for you)" - Morgan Lunt: "A mod is a little TypeScript function that changes how Claude Code actually works. You can rewrite a prompt before it hits the model, block/retry/change a tool call, or even draw your own UI! They work in the CLI and the Claude desktop app." ## Why it matters Everything the AI assistant in this vault does through shell hooks and `settings.json` (blocking commands, injecting context, enforcing conventions) can become a typed function with access to the UI. For teams, the admin controls give a fine-grained, programmatic way to decide what plugins may do. What I'd watch: - **[[Software Supply Chain Security|Supply chain]].** A mod runs inside the process with whatever `

grants it, outside the sandbox. Treat third-party mods like you'd treat a browser extension with access to your terminal - **Stability.** The first week of early access had breaking changes daily. The docs exist now, but the README still says the API can change between releases without notice. I'd use mods for personal setups; for anything a team depends on, expect to fix it after updates ## My take I like the direction. Shipping `/diff` and `AGENTS.md` support as mods turns Claude Code into a small core plus parts you can swap, so you can shape the [[AI Agent Harness|harness]] around the way you work. Asking Claude to write the mod lowers the bar: you describe the pane or the guard you want, Claude writes it, and it runs in the same session without you reading the API docs. Security is where I'd be careful. A mod isn't sandboxed, and its own `$.fs` calls ignore your deny rules. Run `claude plugin validate`, read the code, and only install mods from people you'd trust with your terminal. I'd start with the built-ins (You Should Know first), then write my own mods before installing anybody else's. ## References - Early access announcement (Boris Cherny, 2026-09-14): https://x.com/bcherny/status/2099551291601248485 - GitHub issue #91870 (proposal, community updates, demo videos): https://github.com/anthropics/claude-code/issues/91870 - Built-in mod sources: https://github.com/anthropics/claude-code/tree/main/mods - Mods README: https://github.com/anthropics/claude-code/blob/main/mods/README.md - Mods overview (official docs): https://code.claude.com/docs/en/plugins/mods/overview - Mods admin controls (official docs): https://code.claude.com/docs/en/plugins/mods/admin - Create a mod (official docs): https://code.claude.com/docs/en/plugins/mods/create - Draw in the interface (official docs): https://code.claude.com/docs/en/plugins/mods/interface - React to events (official docs): https://code.claude.com/docs/en/plugins/mods/events - Use the mods API (official docs): https://code.claude.com/docs/en/plugins/mods/api - Test a mod (official docs): https://code.claude.com/docs/en/plugins/mods/test - Troubleshoot a mod (official docs): https://code.claude.com/docs/en/plugins/mods/troubleshoot - Mods reference (official docs): https://code.claude.com/docs/en/plugins/mods/reference - Keyboard shortcuts, band and pane actions (official docs): https://code.claude.com/docs/en/keybindings - TypeScript declarations for mods: https://github.com/anthropics/claude-code/blob/main/mods/types/claude-code.d.ts - Sample mods (token-weather, blast-radius, replay-theater): https://github.com/anthropics/claude-code-playground/tree/main/claude-code/mods - Getting started with Claude Code mods (claude.dev launch guide): https://claude.dev/blog/getting-started-with-claude-code-mods - @ClaudeDevs launch post (X, 2026-10-01) and the You Should Know announcement (X, 2026-10-02) - Boris Cherny on the launch (X, around 2026-10-01) - Morgan Lunt's launch post (LinkedIn, around 2026-10-01) and its comments - Addy Osmani's launch post (LinkedIn, around 2026-10-02) and its comments - Lydia Hallie's video walkthrough: https://x.com/lydiahallie/status/2106127556491821499 - Code modernization plugin: https://github.com/anthropics/claude-plugins-official/tree/main/plugins/code-modernization - prismantis: https://github.com/NahumLitvin/prismantis - claude-markdown-mod: https://github.com/deepskyblue86/claude-markdown-mod - cc-arcade: https://github.com/sezaakgun/cc-arcade ## Related - [[Claude Code]] - [[Claude Code Plugins]] - [[Claude Code Extension Points]] - [[Claude Marketplace]] - [[2026-10-04 Claude Code Mods - Claude Code is now programmable, and mods aren't sandboxed]] - [[2026-10-09 Session Flags - the first Claude Code mod I'm building]] - [[2026-10-04 You Should Know - a second pair of eyes on long Claude Code runs]] - [[Claude Code Hooks]] - [[Claude Code Skills]] - [[Claude Code MCP Integration]] - [[Claude Code Configuration]] - [[Claude Code Permissions]] - [[Claude Code Auto Mode]] - [[AGENTS.md (File Convention)]] - [[Boris Cherny]] - [[Addy Osmani]] - [[Morgan Lunt]] - [[Lydia Hallie]]