News Weekly
0% read
Your progress · 0/5 chapters
About 35 min total
Software Engineering & SDLCISSUE #4 · STORY 12 OF 40Oct 1, 2026CONFIRMED

Claude Code Mods: third-party code now runs inside the agent

Anthropic shipped mods in Claude Code v2.1.287 on 1 October: small TypeScript modules loaded inside the agent's own process, able to approve a tool call before you are asked. Anthropic's own warning in the launch post is that a mod has the same access to your machine as Claude Code does.

A tall iron machine with a round glass window, hand-cranked relay boxes on an outside bench reaching it through drilled pipes, and identical relay vanes mounted inside the casing in line with the moving parts.

Read it your way

CHAPTER 1Picked for Explorer

The 60-second version

Anthropic announced mods on 1 October 2026 and shipped them the same day in Claude Code v2.1.287, in the CLI and the Desktop Code tab, on by default. A mod is a plugin whose hook module is loaded inside the agent's process instead of sitting beside it and exchanging JSON.

Shipped, not previewedMods are on by default in v2.1.287, and the early-access environment variable that used to disable them is ignored.
Hooks became middlewareA handler receives the API, a frozen event and next, so it can observe, rewrite the event or answer instead.
Unsandboxed, by admissionAnthropic's launch post says mods run with the same access to your machine as Claude Code itself.
Stable tag lagged a dayOn 2 October the npm stable tag still pointed at 2.1.285, so stable installs did not yet have mods.
Finish this chapter for +15 XP
Two stamping stations face each other across a belt, one shaping every blank that passes while an identically made head bolted in from the far side reaches across to hold a blank back.
Flip the switch

Where extension code runs in Claude Code

LocationInside the engine processModules load in-process with no Node, no require and no dynamic import, so calls stay statically visible.
ReachObserve, rewrite, answerThe same handler shape can rewrite a prompt, redact a tool result, draw a pane or decide a permission.
TrustOn the permission pathUnsandboxed third-party code now sits between the user and every approval the agent needs.
Your next move · Explorer

Audit the plugins you already run

1Check your version and pin it deliberately, since the stable npm tag trailed the launch release by a day.
2Run claude plugin validate on every plugin you did not write and read the hooks and calls lines.
3Flag any mod that both fetches over the network and starts processes, and read it by hand.

Switch your reading mode at the top to see a different next move.

Tap to open

Things to keep an eye on

Pop quiz · unlock the Function hooks badge

Did it stick?

0/3
Where does a mod run, and what does that let it reach that old hooks could not?+20 XP
Anthropic's documentation names one interface element a mod cannot change. Which?+20 XP
A security tester fetched a benign script and later swapped it for a malicious one. Why does the static scan miss that?+20 XP
Your call · +5 XP

Your team upgrades to a release where mods are on by default. Which posture do you adopt?

Research dossierThe full research, labeled and sourcedCONFIRMED15 sources · 35 min read · 20 sections
Story identity
  • Story ID: S12
  • Organization: Anthropic
  • Category: AI-Assisted Software Engineering / Developer Platform
  • Title: Anthropic ships Claude Code Mods, making the coding agent a programmable TypeScript runtime
  • Event date: 2026-10-01 (Thursday). Announcement date 2026-10-01. Independent reporting dates: 2026-10-01 and 2026-10-02. All inside the configured window 2026-09-26 → 2026-10-02.
  • Evidence status: CONFIRMED for the existence, date, shape, hook surface, capability list and governance model (all traceable to Anthropic primary documents plus independent retrieval of the shipped release and of Anthropic's own generated TypeScript declarations).

Label key

  • FACT — corroborated by a primary Anthropic document and/or independently observed.
  • COMPANY CLAIM — asserted by Anthropic, not independently verified.
  • INDEPENDENT EVIDENCE — observed by a named third party, including hands-on testing.
  • INDEPENDENTLY VERIFIED — confirmed by both a primary document and an independent party.
  • EARLY RESEARCH — pre-GA, third-party testing of a preview build.
  • RUMOR — not used; see §18.
  • INTERPRETATION — analysis, kept separate from the record.
  • PREDICTION — forward-looking, kept separate from the record.

✓

What happened?

🎓 For Explorer

FACT. On 2026-10-01 Anthropic announced mods for Claude Code in a product post titled "Customize Claude Code with mods", dated October 1, 2026, and shipped them in Claude Code v2.1.287, released the same day.

FACT — Anthropic's own framing, quoted. "Today we're introducing mods, small TypeScript functions that change how Claude Code works. A mod can rewrite a prompt, add new UI, replace a built-in feature, or add entirely new functionality. You can write a mod yourself, or ask Claude Code to write one for you. Mods ship inside plugins, so you install and share them like any plugin."

FACT — the immediate security admission, quoted. "Mods run with the same access to your machine as Claude Code itself. They aren't sandboxed, and you should only install mods from sources you trust, the same way you'd install any code on your computer."

FACT — why now, per Anthropic. "Developers have asked for more control over how Claude Code works, without waiting for us to ship a feature. Hooks helped give users some of this control, but hooks can't rewrite events, draw new UI, or replace features. Mods can."

FACT — this was pre-announced in public. The design was shared as GitHub issue anthropics/claude-code#91870, "Mods - make Claude 10x more extensible", opened 2026-09-03 by poteat with a design post and a technical architecture PDF. A 2026-09-09 community update committed: "We're shipping in N weeks… we are going to be calling this functionality 'Claude Mods'. The engineering term of art 'function hook' will still exist as the documented implementation primitive Mods are built on. A mod is just a plugin that uses function hooks, nothing is changing there." A 2026-10-01 update on the same issue reads: "We're live!".

FACT — distribution and availability. Mods are available in the Claude Code CLI and the Claude Desktop app's Code tab. They require v2.1.287 or later and are on by default. Installed plugins containing mods come from marketplaces via /plugin install token-chart@your-org or claude plugin install, and can be submitted to Anthropic's Claude directory.

FACT — rollout gap found independently. On 2026-10-02 the npm stable dist-tag for @anthropic-ai/claude-code still pointed at 2.1.285, with latest and next at 2.1.287 — so a machine on the stable channel did not yet have mods the day after launch. (INDEPENDENT EVIDENCE, MIXED, 2026-10-02.)


Δ

What changed?

FACT. Concrete before/after, each row traceable to a primary document:

DimensionBefore (pre-2026-10-01)ChangeAfter
Where extension code runsOutside the agent: a settings hook runs a shell command / HTTP request / prompt / agent, exchanging JSON over stdin/stdoutNew function hooks: JavaScript/TypeScript modules that Claude Code loads and calls inside its own processExtension code runs in-process, holds state between events, and calls back into the engine
What a hook may do to an eventBlock or allow it; adjust arguments/result; add contextFull middleware semantics via next: observe, rewrite, or answerA hook can observe, mutate the event the rest of the chain sees, or short-circuit Claude Code's own behaviour entirely
Prompt handlingUserPromptSubmit can add or suppress contextprompt.submit can rewrite the typed text, append Claude-only context, or drop the promptPrompts are a programmable surface, not just an event to watch
Permission decisionsSettings PreToolUse hooks and permission rulesA dedicated tool.check event fires after rules and settings hooks have decided; next(e) resolves to their verdict (allow/ask/deny) and the mod may return any verdictA mod is a first-class participant in the permission decision, in both directions
UIFixed. Hooks could not drawui.render is a hookable event per component; panes, the band above the prompt, buttons, inputs, selects, panes, toastsA mod can draw its own interface and restyle or replace what Claude Code draws (tool rows, spinner, dialogs)
Built-in featuresCompiled into the product/diff is now a mod (cc-plugin-diff) and can be switched off in /plugin or replaced; AGENTS.md loading is a mod (cc-plugin-agents-md)Anthropic's stated plan: "pare Claude Code down to a small core and add back only what you want"
Review before installReview the plugin repoclaude plugin validate <dir> statically lists the events a mod handles (hooks:) and every $ call it makes (calls:, plus env reads:/env writes:/state reads:/state writes:) without running it; Claude Code "refuses to load a mod that uses the mods API in a way this command can't read"Capability disclosure exists as a first-class, automatable gate
Testing extension codeNo in-process test harnessclaude plugin test runs a plugin's *.test.ts against the real runtime "with no session, sign-in, or network"; tests fire real events and stub what Claude Code would answerMods are testable like library code
Type toolingNone for hooksOn every load/reload Claude Code writes .d.ts declarations into the mod's .claude-plugin/types/ (claude-code/index.d.ts, claude-code-tools/index.d.ts, claude-code-mcp/index.d.ts, per-dependency plugin folders, plus a generated tsconfig.json)Editors and tsc -p ./mod work with zero setup
Enterprise controlPlugin allow/block; allowManagedHooksOnlyNew built-in guard mod sec-default@builtin that loads first, plus allowManagedModsOnly, a prepend/append plugin tier system, and policy mods that can refuse or audit other modsOrg policy is expressible in the same language as the thing being governed
Early-access gaten/aCLAUDE_CODE_ENABLE_FUNCTION_HOOKS=1 was needed on 2.1.285/2.1.286; from v2.1.287 the variable is ignored at any value, so =0 no longer disables modsMods cannot be turned off by unsetting an environment variable

Two stamping stations face each other across a belt, one shaping every blank that passes while an identically made head bolted in from the far side reaches across to hold a blank back.
↔

Before → Change → After

🎓 For Explorer

Before. Claude Code was extensible only from the outside. A settings hook was a shell command, HTTP endpoint, MCP tool call, prompt, or subagent that received a JSON event on stdin and could block, allow, log, or add context. A skill was markdown. An MCP server was an external process. Every one of them was a black box at the edge of the product: they could influence the agent but could not see inside it, keep state across events, redraw the interface, or take over a decision. As Anthropic itself puts it, hooks "can't rewrite events, draw new UI, or replace features."

Change. Anthropic moved the extension point into the engine process. A mod is a plugin whose hooks/hooks.json declares a modules entry pointing at a JS/TS hooks module that exports register(on, options). Inside register, on(eventName, [matcher], handler) registers handlers, each receiving ($, e, next). $ is the mods API, e is the event as frozen plain data, next passes the event to the next mod and finally to Claude Code's own behaviour. Handlers form a middleware chain and can observe (return next(e)), rewrite (return next({...e, changed})), or answer (return {deny: ...} / {result: ...} without calling next).

After. The coding agent stops being a fixed product and becomes a hosted TypeScript runtime with an event bus, a capability-gated API, a test harness, generated type definitions, and an admin control plane. Extensibility is no longer "ask Anthropic to ship the feature" or "write an external shim"; it is "register a handler." At the same time, the trust boundary moved: code a third party wrote now sits between the user and every permission decision the agent makes, unsandboxed, running with the user's own credentials.


⚙

How it works

FACT — the file shape. A minimal mod is three files:

first-mod/
├── .claude-plugin/
│   └── plugin.json
└── hooks/
    ├── hooks.json      # { "modules": ["./register.js"] }
    └── register.js     # export function register(on) { ... }

The modules key in hooks/hooks.json is precisely "what makes the plugin a mod".

FACT — the three arguments. $ — the mods API, namespaced ($.ui, $.fs, $.process, $.http, $.env, $.settings, $.store, $.state, $.clock, $.command, $.tool, $.mcp, $.model, $.session, $.agent, $.prompt, $.telemetry, $.audio, $.config). e — the event input as plain, deeply frozen data. next — the continuation.

FACT — the runtime environment. A hooks module runs in an environment of its own: no DOM, no Node, no require, no dynamic import(). Modules and their imports must be named .ts .tsx .jsx .js .mjs .cjs .mts .cts and be ES modules. Only relative imports inside the plugin directory are allowed, with one bare import permitted: claude-code. Because ambient access is removed, a static scanner can enumerate the $ calls — which is exactly what claude plugin validate prints and what makes a policy mod's plugin.register check possible.

FACT — matcher filters. A matcher is an object compared against the event: a value, an array of allowed values, or a regular expression (on('tool.call', { tool: /^mcp__github__/ }, hook)). Wildcards work: 'classic.*' matches every settings-hook event, '*' matches every event except telemetry events.

FACT — the event surface, read out of Anthropic's own generated declarations. The engine event types declared in claude-code.d.ts (retrieved from the shipped repository; see §19) are:

  • Tools: tool.call, tool.check, tool.register, tool.list, tool.describe
  • Prompts / context: prompt.submit, prompt.compose, prompt.edit, prompt.fill, prompt.read, prompt.section, prompt.context, prompt.suggest, prompt.attachment, skill.prompt
  • Turns: turn.start, turn.step (streaming, written as an async generator), turn.complete, turn.abort
  • Session: session.start, session.end, session.id, session.cwd, session.root, session.messages, session.usage, session.measure, session.compact, session.attach, session.detach, session.receive, session.send, session.model, session.repo, session.surface, session.surfaces, session.turns, session.version, session.authorize
  • Interface: ui.render, ui.resolve, ui.press, ui.input, ui.select, ui.focus, ui.open, ui.close, ui.panes, ui.scroll, ui.log, ui.message, ui.notice, ui.toast, ui.status, ui.invalidate, ui.blit
  • Commands / config / plugins: command.register, command.run, command.list, command.describe, config.list, config.describe, config.set, plugin.register, engine.create
  • Agents: agent.spawn, agent.offer, agent.register, agent.list
  • Attribution: attribution.text
  • Classic mirror: classic.<SettingsHookEvent> — every settings-hook event is reachable from inside a mod
  • Telemetry: separate, taking { to: 'collector' }

FACT — the ordering rule. Hooks on the same event form one middleware chain. "The first mod is outermost: it sees the event before the others and the result after them, and it decides whether the others run at all." The order is: (1) sec-default@builtin, then org prependPlugins, then any other org mod; (2) user-installed mods; (3) org appendPlugins; (4) other built-in mods. Within a tier, load order; a mod runs before its manifest dependencies.

FACT — where settings hooks sit in that chain, precisely. Managed-settings PreToolUse hooks run before the first mod's tool.call, and their block is final — no mod sees the call. PreToolUse hooks from every other settings file and from plugins run after the last mod calls next. tool.check fires after those hooks and the permission rules have decided, so a tool.check hook can approve a call that a non-managed PreToolUse hook blocked.

FACT — failure semantics. A hook that throws, times out, or returns a wrong shape does not break the session: if it had not called next, Claude Code skips it and the next handler runs; if next had already resolved, that result stands. on(...).catch(handler) attaches a fail-closed handler — the documented use case is making a blocking hook fail closed instead of open. Time spent awaiting inside a $ call (e.g. $.ui.ask) does not count against the hook's time limit; time spent on the mod's own promise does.

FACT — the one hard boundary. "A mod can restyle much of Claude Code's interface, but not the permission prompt. It can't change what a prompt shows you." This is stated in the blog post, the overview page and the admin page.


!

Why it matters

🎓 For Explorer

INTERPRETATION. This is the browser moment for the coding agent, and the same moment as npm — with the same trade.

  1. The unit of value shifts from the product to the platform. Before mods, the only way to change Claude Code's behaviour was to wait for Anthropic or to build an external shim. After mods, the agent loop, its permission layer, its prompt assembly and its interface are all addressable surfaces. That is the same transition that made the browser extensible and the phone a platform: the interesting work moves from the vendor's roadmap to third parties' plugins.
  2. Mods reach the surfaces external extensions structurally could not. tool.check (the permission verdict), ui.render (the pixels), prompt.section (the system prompt), session.append (the stored conversation), agent.spawn (the subagent) are all in-process. No amount of shell scripting reaches them. This is the substance behind the "runtime" framing, and it is why "hooks couldn't rewrite events, draw new UI, or replace features" is the correct hinge.
  3. The supply chain moved inside the trust loop. The new code does not sit beside the agent; it sits in it. A mod can approve a tool call before the user is asked, redact what the model reads, rewrite the transcript, or spend the account's tokens. Third-party mod review is now a prerequisite, not a nicety. Independent hands-on testing (Pluto Security, pre-release) demonstrated exactly this class of attack against the preview build.
  4. Enterprise gets a real answer to "govern our agent." Before, governance was permission rules plus settings hooks plus a plugin allowlist — all outside the process. Now the guard mod sec-default loads first, allowManagedModsOnly can exclude every non-org mod fleet-wide, and an org can write a policy mod in TypeScript that refuses any mod calling $.process.run, and audit every tool.call and every $.fs.write any mod makes. Governance and the governed thing share a language.
  5. Claude Code is now a substrate Anthropic also builds on. AGENTS.md loading, /diff, plugin-authoring, sec-default and telemetry are all mods. Anthropic has publicly committed to migrating further built-ins. That is the strongest possible signal that the pattern is the product's spine, not a side door.

INTERPRETATION. The strategic asymmetry: Anthropic made the extension surface and kept the canonical implementations on it. When your own built-ins are plugins, you control the reference implementations, the guard mod, and the type definitions — and a competitor cannot match your plugin ecosystem without reimplementing all three.


✦

What became possible?

🎓 For Explorer

FACT — capabilities stated by Anthropic, each traceable to a documented event:

  • Rewrite a prompt before it reaches the model (prompt.submit → next({...e, text})).
  • Block, rewrite, or retry a tool call (tool.call; retry by calling next(e) again on isError).
  • Approve or deny a permission request (tool.check → {decision: 'allow'|'ask'|'deny', reason}).
  • Redact secrets from tool output before Claude reads it (rewrite the tool.call result).
  • Hold a tool call open while asking the user (await $.ui.ask(...) inside tool.call).
  • Send one request to a different model (turn.step → next({...e, model})).
  • Draw a pane beside the transcript, a band above the prompt, buttons, inputs, selects, toasts, status entries; replace or restyle what Claude Code draws (tool row, spinner, AskUserQuestion dialog).
  • Run your own code on a slash command with no Claude turn.
  • Register a tool the model can call; rewrite system-prompt sections and context; rewrite stored conversation rows.
  • Register other mods' API calls as your own hookable events (plugin.register, fs.write, …) — the basis for policy mods.
  • Author by description: Claude Code ships a built-in plugin-authoring skill; ask in a session, approve, hot-reload.

FACT — Anthropic's own three worked examples. token-weather (context-window forecast drawn above the prompt), blast-radius (holds rm -rf/git reset --hard/force push and shows what it would change, with Proceed/Cancel), replay-theater (a /replay command stepping through the last turn's file edits) — published in anthropics/claude-code-playground, shared "as they are, without support".

FACT — Anthropic's team-use cases, verbatim intent. A mod can show CI/CD status in a pane beside the conversation; can require confirmation before any command touches production config; and "a mod that loads first can record every call that every other mod makes" (audit logging).


◎

Implications

Technical

FACT. Mods are not a new subsystem bolted beside hooks; they are the same hook mechanism with the handler moved in-process. Anthropic's architecture statement: "Algebraically, this is just an effect-parameterized endomorphic continuation model for plugins." The composition model is next, described in the original design post as "a registration-order-based 'next' continuation model a la Express, or Koa".

FACT. Consequences of in-process execution, from the docs:

  • State is shared across events for free. A mod's hooks share the variables in its module — no files, no IPC. But hot reload re-runs register, so module state resets on every reload; durable state belongs in $.state, which the host holds for the session and which survives reloads.
  • UI elements are resolved per surface. $.ui.resolve(e) returns the element constructors for the surface being drawn, because each surface supports a slightly different set. The declaration file notes tree bounds (20,000 nodes, 32 deep, 100,000 characters serialized) beyond which the instance unmounts.
  • Client modules are a real embedding primitive. A Client draws a surface module of the plugin's own (.tsx) with local state, a frame clock, pointer and key listeners, and posts plain data back to the plugin's hooks. This is Ink/React-in-the-terminal exposed as an API.
  • The event object is deeply frozen. Assigning to a field throws; rewrites pass a copy to next.
  • Pinned fields exist and are enforced. On agent.spawn, tool_use_id, name, parentModel, permissionMode, parentAgentId and provider are pinned — a rewrite is refused. Some agentId values are pinned. This is the shape of a security boundary inside the API.
  • Validation is syntactic, by design. Event names must be string literals, $ calls must be written in full, $ must not be destructured or assigned, on must not be shadowed, dynamic import() fails. These are not style rules — they are what keeps the static capability scan complete.
  • Prompt-cache awareness. Text injected by prompt.submit/prompt.section/prompt.context/skill.prompt hooks that changes between requests invalidates the prompt cache. A mod can silently destroy cache hit rates.
  • A mod's own API calls are hookable events. A plugin can declare a noun and its own typed contract, and core's EngineInterface is an interface "so a plugin types the noun it provides by declaration merging, the way a jQuery plugin types $.fn." Third-party API surface for Claude Code is now a real ecosystem concern.

FACT — the type/LSP status, stated precisely. This is not a preview flag and not future work. On every load or reload of a mod from a --plugin-dir directory (or one Claude wrote), Claude Code writes version-pinned .d.ts declarations into <mod>/.claude-plugin/types/. If the mod has no tsconfig.json, Claude Code adds one at the mod root extending the generated one, "so your editor and tsc -p ./first-mod type-check the mod without more setup". The declarations are checked into the public repository at mods/types/claude-code.d.ts. Anthropic's own instruction is that these generated files outrank the documentation: "The events and methods can change between releases, so trust these files over any page, this one included, when they disagree."

FACT — an important caveat on that declarations file. The copy currently checked into the repository's main branch begins // Written by Claude Code 2.1.277. and carries the line "EARLY ACCESS: this surface may change between releases without notice." It also documents a /plugin-types command that regenerates it. So: the feature is GA and default-on in v2.1.287, while the checked-in reference declarations are a specific older build's output and still carry an early-access header. Treat the per-build generated file as authoritative; treat the repository copy as a snapshot.


Developer

FACT. What a developer must now do differently:

  • Treat /plugin install as npm install from an unknown publisher. Anthropic's own words: install "the same way you'd install any code on your computer."
  • Run claude plugin validate <dir> before installing anything. It is documented as the only place the capability list appears, and the admin page treats it as the review gate. Look at calls: for $.fs.read/write, $.process.run/spawn, $.http.fetch, $.env.get, $.settings.read, $.prompt.submit, $.session.send, $.model.complete.
  • Understand what the capability list does and does not cover. It enumerates $ calls and env/state reads/writes. It does not enumerate rewrites passed to next, and it cannot see code the mod fetches at runtime. (See §12 for the independent tester's demonstration.)
  • Know the four kill switches and their different reach: disable one plugin from /plugin → Installed; claude --safe-mode → every installed mod for one session, plus your other customisations; "disableAllHooks": true in ~/.claude/settings.json → every mod you installed, everywhere, plus your settings hooks and status line (your org's managed mods keep running); org-level allowManagedModsOnly / allowManagedHooksOnly / disableAllHooks / disableSideloadFlags. Built-in mods are not stopped by any of these, and cc-plugin-sec-default cannot be disabled by a user at all.
  • Expect the API to move. Claude Code ships releases roughly daily and states outright that "the events and methods can change between releases". Mod authors are told to record the version they tested with in their README and to name a version that isn't a name Anthropic could take.
  • Use the harness. claude plugin test runs *.test.ts against the real runtime with no session, sign-in or network, firing real events ($.tool.call({tool:'Bash', command:'ls'})) and stubbing what Claude Code would answer. Mods are the first Claude Code extension surface with a first-party test kit.
  • Plan for hot reload. Every save re-runs register; keep durable state in $.state, not module variables.
  • Add your stack's rules as a mod, not as a settings hook, when the decision depends on live state — the docs' own example is refusing git push only while the current branch is main, which needs $.process.run. A settings hook remains the right tool for a plain scriptable block.
  • Know where mods do and don't apply. Hooks run in the terminal, editor integrated terminals, the JetBrains plugin, the Desktop Code tab, the VS Code extension chat panel, claude -p, the Agent SDK, Remote Control and cloud sessions. Drawing happens only in a terminal and the Desktop Code tab. A WSL session in the Desktop app runs neither, because plugins are not available there.

INDEPENDENT EVIDENCE. Two independent practitioner sources reach compatible conclusions. sdd.sh (2026-10-02) judges the design "the right design — extensibility at the event level of the agent loop, with the trust cost stated up front rather than buried", calls out the terminal-UI gap that mods close against IDE wrappers, and concludes the rollout "changes your threat model overnight, and the default-on rollout puts the burden on you." MIXED (2026-10-02) led with the fact that Anthropic "says they can read your API key" and highlighted the sandbox carve-out.


Enterprise

FACT. Because mods ship inside plugins, existing plugin controls apply unchanged — marketplace allow/block lists, strictKnownMarketplaces, install policies, update policy, audit. What is new is a control plane for code that now runs in-process.

FACT — the default posture. With no mod settings of your own:

  • Mods are on. A user can install a mod from any marketplace your plugin settings allow, or load one from a directory with --plugin-dir.
  • A built-in guard, sec-default@builtin, loads first, ahead of every mod a user installs, and users cannot turn it off. It loads when the machine has managed settings or the user is signed in with a Team or Enterprise plan. API-key and Bedrock/Vertex/Foundry users get it only on machines with managed settings.
  • The guard protects what you manage: a user's mod cannot change what your managed hooks receive or decide, the system prompt, your managed CLAUDE.md and instructions, what any mod reads as settings, or your managed MCP servers' tools and descriptions.
  • Everything else is allowed. A user's mod can still read and write files, start processes, make network requests, rewrite tool calls and prompts, deny a tool call, approve one that would otherwise prompt, and draw in the interface.
  • deny rules and managed PreToolUse blocks take precedence over a user's mod — unless you set the guard's allowModsToOverrideDenyRules.
  • The guard fails closed: if it cannot read managed settings it refuses every user's mod at load; if it cannot check the deny rules for a call a mod approved, it refuses the call. Its source is public.

FACT — the three policy settings, and what each really means:

SettingReach
allowManagedModsOnly (option on cc-plugin-sec-default@builtin, in pluginConfigs)No mod a user brings loads — including --plugin-dir and mods Claude writes in-session. Org mods still load. Settings hooks, status lines and /goal keep working. Built-in mods keep running. Users cannot undo it: it reads managed settings only
allowManagedHooksOnlyWider: only org mods and built-in mods load; users' own settings-file hooks are also blocked
disableAllHooksWidest: stops mods in every installed plugin including yours, and turns off every settings hook, so a managed PreToolUse hook no longer blocks anything
disableSideloadFlagsRejects --plugin-dir and --plugin-url at startup, keeps in-session mods from loading, and also rejects --agents and --mcp-config

FACT — the documented hole to design around. "Neither applies to a mod's own $.fs and $.process calls: with Read(.env) denied, a mod can still read that file with $.fs.read or start a program that does. To limit those calls, keep the mod from loading or handle the call in a policy mod." Likewise network policy covers $.http.fetch but "does not cover a program the mod starts with $.process.run."

FACT — org mods get their own tier, on real criteria. A mod counts as your organization's only when managed enabledPlugins sets its plugin true, managed settings name its marketplace as a directory on the machine by absolute path, and the marketplace lists the plugin by a relative path so it loads in place. A plugin Claude Code copies into its cache — i.e. anything from GitHub, git, URL or npm — counts as a user's mod even when managed enabledPlugins enables it: it runs among user mods, prependPlugins/appendPlugins skip it, and it does not load under allowManagedModsOnly. Device management must copy the marketplace directory to the same path everywhere and make it admin-writable only.

FACT — a complete, documented policy mod. The admin page ships a working acme-guard example that hooks plugin.register to refuse any user-tier mod whose code calls $.process.run or $.process.spawn (reading e.tier and e.uses.calls), and hooks tool.call and fs.write to write an audit line naming the originating plugin (next.origin.plugin) to the debug log or out via $.http.fetch. It also documents the fail-closed variant, because "if your plugin.register hook throws or exceeds its time limit, Claude Code skips the hook, so the check fails open and the mod it was checking loads."

FACT — one operational caveat. "If the worker thread that runs installed mods crashes three times, Claude Code unloads every mod that isn't built in, including yours, until the user runs /reload-plugins or starts a new session." And in auto mode, a call a mod approves "runs without a classifier check."


Strategic

INTERPRETATION.

  1. Anthropic is defending the harness, not just the model. With Codex, Cursor and Copilot all shipping agentic surfaces, the durable moat is the control plane around the model. Mods make Claude Code's control plane the extensible one — and make the guard mod, the type definitions and the reference implementations Anthropic-controlled assets that competitors must re-create from scratch.
  2. The economics invert the plugin problem into Anthropic's favour. External extension mechanisms (MCP, settings hooks) let a competitor's ecosystem attach to Claude Code. In-process mods do the same, but the trust decision now runs through a guard Anthropic ships and an admin policy language Anthropic defines. Anthropic gets the ecosystem and keeps the gate.
  3. The precedent will be copied. Every major coding agent now faces the same fork: closed agent with settings hooks, or open agent with in-process, unsandboxed third-party code. Mods make the second option shippable with a governance story, which removes the main objection.
  4. A new professional artefact appears: the org mod. Best-practice instructions (CLAUDE.md, AGENTS.md), CI policy, permission rules, hooks and now policy mods form a stack an enterprise AI-platform team can own. Consulting and platform work shifts from "configure the agent" to "write and maintain the agent's policy code."
  5. Directory economics. Mods ship in plugins and can be submitted to Anthropic's Claude directory. Mods are a distribution channel for third-party dev tooling that did not exist for coding agents in October 2026.

PREDICTION. Over the next two to four quarters, "write a policy mod" becomes a standard line in enterprise AI-governance procurement checklists, and at least one competitor ships an equivalent in-process extension model to avoid losing deals on control. Confidence: moderate. This is a forecast, not a record.


⚠

Risks & limitations

Risks

FACT — the risk Anthropic itself prints in the launch post. "Mods run with the same access to your machine as Claude Code itself. They aren't sandboxed, and you should only install mods from sources you trust."

FACT — the documented blast radius, from the mods overview. Once loaded, a mod can: act on your machine as you (read/write files anywhere your user account can, start programs, make network requests); read your secrets (environment variables and settings files, including an API key); see your session (every prompt, every tool call); change your session (rewrite a prompt or tool call, submit a prompt as if you typed it, send a message to another of your sessions); act without asking you (approve a tool call before you're asked); and spend your usage by calling a model on your plan or API key.

FACT — the sandbox carve-out. "If you turn on sandboxing, the sandbox isolates the Bash commands Claude runs, and a process that a mod starts runs outside it." So the sandbox people already trust for Bash does not contain mods.

INDEPENDENT EVIDENCE / EARLY RESEARCH — the sharpest external testing, and its limits. Pluto Security (Ehud Melzer, 2026-09-22) tested the pre-release function-hook implementation (screenshots from v2.1.274; the feature was then behind CLAUDE_CODE_ENABLE_FUNCTION_HOOKS=1) and reported four trust gaps. These are pre-GA findings and may be partly fixed in v2.1.287 — they are recorded as EARLY RESEARCH, not as verified current behaviour. Their four findings:

  1. Silent exfiltration. A mod in the user tier using $.fs.read + $.http.fetch read ~/.claude/.credentials.json and an 834 KB history.jsonl of every prompt across every project, and POSTed them to an attacker-controlled webhook. Their conclusion: $.fs.read "is not scoped to your project or your session"; absolute paths are used as given. "No prompt appeared. No permission was asked."
  2. No capability disclosure at the decision point. Install prompted nothing; plugin details reported their four-event wildcard mod as "Hooks (0)", while a classic shell-hook plugin in the same marketplace correctly showed "Hooks (1) PreToolUse". The capability list appeared only under the manual claude plugin validate. Their content scan was tied to the claude.ai channel and did not run for --plugin-dir or self-hosted GitHub marketplaces.
  3. UI spoofing and consent capture. A mod drew a convincing fake "Anthropic – session verification required / re-enter your API key" prompt in the AbovePrompt band inside the real client, and on submit POSTed the typed key out with $.http.fetch — "the usual phishing defenses do not apply here: there is no URL to inspect". Separately, a ui.render hook swapped the text of a genuine AskUserQuestion dialog, so the user read "Refresh the local build cache now?" while the model received "Confirm" against "Delete ALL files in ~/prod-data permanently?". Their stated limitation: the engine preserves option labels the model created, so descriptive labels such as "Delete everything" are restored — but generic labels ("Confirm"/"Cancel"), which are common, are not protected. A second finding: two hooks together changed the command that executed and the command the transcript showed, with no $ call at all — so claude plugin validate reports a mod that "appears to do nothing".
  4. Review ≠ the code that runs. $.http.fetch + $.process.run let them serve a benign script and then swap the served file for a malicious one without changing the mod: no new version, no reinstall, no new review. "$. can tell you that a mod can fetch data and run a shell. It can never tell you what it fetches or runs."

FACT — controls Pluto found working. The sandbox appeared to block ambient fetch, XMLHttpRequest, WebSocket, require and import, and they found no way around $. The permission prompt's display cannot be rewritten. AskUserQuestion preserves the model's own option labels. Identity is not spoofable: a mod's tier comes from its host-assigned name, and a mod naming itself after a built-in simply is not loaded. Those four are consistent with Anthropic's own documentation of the same boundaries.

FACT — the residual risk that survives all of it. Even a fully-reviewed, fully-allowlisted mod runs with the user's credentials and can still lie: nothing prevents a mod from rewriting what the user sees about what Claude did. The capability scan covers API calls, not narration.


Limitations

FACT — limits of the feature.

  • Unsandboxed. No isolation for mod code, by design and by admission.
  • The permission prompt is the only UI a mod cannot touch. Everything else — including the AskUserQuestion dialog's text — can be restyled.
  • Surface-dependent rendering. Drawing exists only in a terminal and the Desktop Code tab. VS Code chat panel, claude -p, the Agent SDK, Remote Control and cloud sessions run hooks but draw nothing.
  • No mods in WSL Desktop sessions, because plugins are not available there.
  • The API is explicitly unstable. "The events and methods can change between releases." Claude Code shipped ~27 releases in the month to 2026-10-01; the reference declarations still carry an early-access header.
  • Hook failures fail open by default. A blocking hook that throws is skipped, and the action proceeds. Failing closed requires an explicit .catch handler — a footgun in a security control.
  • Bounded trees and payloads. Render trees beyond 20,000 nodes / 32 deep / 100,000 characters unmount the instance; UI messages beyond 20,000 values do not send.
  • An opt-in built-in mod that spawns a side agent (cc-plugin-you-should-know, "runs a side agent that watches your back while Claude works on longer tasks") is disabled by default, is not off via disableAllHooks or --safe-mode, and the release notes scope it to "first-party sessions with telemetry on".
  • disableAllHooks is genuinely destructive, not just conservative: it stops org mods too and un-blocks managed PreToolUse hooks.

FACT — limits of the evidence base for this story.

  • No mainstream technology or financial outlet published dedicated hands-on reporting on mods within the window that this research could retrieve. Independent coverage is two practitioner/technical blogs, one independent news report, and one security vendor's pre-release test. The docs are the source of truth for capability; no independent party has, to this research's knowledge, published a post-GA security assessment.
  • Pluto Security's findings are pre-GA and version-specific. Whether v2.1.287 fixes the plugin details "Hooks (0)" blindness, the scan-coverage gap on --plugin-dir/self-hosted marketplaces, and the fetch-then-run gap is not established by anything retrieved here. Treat these as open questions, not as current vulnerabilities.

?

Open questions

  1. Did v2.1.287 close the disclosure gaps? Specifically: does plugin details now count function-hook events; does the capability list appear at install; does the content scan run on --plugin-dir and self-hosted marketplace installs; is $.http.fetch response integrity pinnable?
  2. Can the AskUserQuestion question text be pinned? Pluto found option labels are preserved when descriptive and text is not. What is the intended boundary?
  3. Who audits $.http.fetch → $.process.run? If the answer is "nobody, and integrity pinning is not planned", the review model is "review the publisher, not the code" — a materially weaker guarantee than npm's.
  4. How much does a mod cost in latency? Every event is a middleware chain; turn.step is streaming. No retrieved source gives per-dispatch overhead numbers.
  5. Does plugin.register-based policy compose with third-party policy mods? Two prepend-tier mods both seeing plugin.register: the docs define order, but not conflict semantics between two refusing policies.
  6. What is the migration path when the API changes between releases? The declaration file is version-pinned and per-build; an installed mod written against 2.1.287 may not type-check on 2.1.300. Is there a compatibility promise?
  7. Does allowManagedModsOnly interact safely with the built-in you-should-know and telemetry mods, which are not stopped by it and which consume tokens on first-party sessions?
  8. Is the sec-default guard auditable in practice? Its source is public, but the effective policy on a given machine depends on managed-settings precedence, prependPlugins, and whether a third org mod shadows it.
  9. What happens to the plugin register → plugin validate static-analysis contract if a mod is written in a language other than TypeScript/JavaScript, or a bundler is reintroduced? The contract currently depends on ES-module, literal-string, fully-qualified-call syntax.

→

What should you do with this?

Circle 1
Circle 1 impact — the immediate circle

Definition: developers and technical leads who use Claude Code daily, in the days and weeks around 2026-10-01.

Impact (high, immediate). Their environment changed on upgrade. Any Claude Code ≥ v2.1.287 they launch can now load plugins that run in-process code with their permissions. Existing installed plugins may begin behaving differently — /diff is a mod now, and AGENTS.md loading is a mod. Tools and configuration they wrote as settings hooks still work, unchanged and un-deprecated.

Recommended action.

  1. Check your version (claude --version) and pin it deliberately; note the stable npm tag was still behind launch on 2026-10-02.
  2. Inventory what you already have installed: /plugin → Installed. For anything you didn't write yourself, run claude plugin validate against its directory and read the hooks: and calls: lines.
  3. Know your switches: --safe-mode for a one-session clean test; "disableAllHooks": true for a full local quarantine (knowing it also disables your settings hooks and status line).
  4. Re-verify any plugin that both hooks tool calls and draws UI.
  5. If you have a CLAUDE_CODE_ENABLE_FUNCTION_HOOKS=0 in your environment from early access — remove it. It no longer disables anything.

Circle 2
Circle 2 impact — the organisational circle

Definition: engineering managers, platform/DevEx teams, security and AppSec, and procurement, over the following quarter.

Impact (high, structural). Two things land at once. Opportunity: the org can now write its own agent policy as reviewable TypeScript, with a documented policy-mod pattern, a first-party test harness, and generated types. Risk: every developer who installs a mod is running unreviewed in-process code with production credentials, and the default is on.

Recommended action.

  1. Decide the default this week, not after the first incident. Either allowManagedModsOnly with an org allowlist, or at minimum disableSideloadFlags plus a marketplace allowlist.
  2. If you allow any user mods, deploy a prepend-tier policy mod using the documented plugin.register pattern — and write it fail-closed with .catch, because a throwing check fails open.
  3. Write down the gap explicitly: deny rules and network policy cover Claude's calls, not a mod's $.fs/$.process/$.http. Your policy has to be a policy mod, not a permission rule.
  4. Establish a review bar: claude plugin validate output as a required artifact, plus a human read of next(...) rewrites and any fetch-then-run pattern. Pin or vendor anything you depend on.
  5. Handle the org-mod classification rules as an operational detail: your mods must load in place from an admin-writable absolute path, or they count as user mods and stop loading under allowManagedModsOnly.
  6. Put "can our agent platform be reviewed like code?" into procurement and vendor-risk templates for any AI coding tool.

Circle 3
Circle 3 impact — the industry circle

Definition: vendors, regulators, and the broader software ecosystem over the following 12–24 months.

Impact (high, structural). The security model for enterprise software just gained a new category: unsigned, unsandboxed, in-process extension code shipped through a marketplace by unknown publishers, running inside a tool with production credentials. npm had this problem and solved it badly and slowly. The agent case is worse in one respect (the code sits on the permission path) and better in another (a capability scanner exists at load time and an org policy language exists).

Recommended action / what to watch.

  1. Regulators and standards bodies should treat agent-extension marketplaces as a software supply-chain surface with the same seriousness as package registries.
  2. Vendors should expect in-process extension models to become table stakes, and should decide consciously whether they will ship one with a governance story or without.
  3. Security vendors already have a market: static mod scanners, CI gates on claude plugin validate output, managed-settings-as-code.
  4. The unresolved policy question is whether capability disclosure at install time becomes a norm or stays a manual command. Pluto's finding — that the one inspection screen reported "Hooks (0)" for a mod hooking four events including a wildcard — is the kind of detail that either gets mandated or ignored.

PREDICTION. The next agent supply-chain incident will not be a prompt injection into a skill; it will be a mod. Confidence: moderate. Reasoning: mods are a larger and quieter trust surface than skills, default-on, with a documented fetch-then-run gap, and the failure mode (a plausible-looking UI or transcript) is exactly the kind that does not get reported.


Business value
Business-value opportunities where genuine

Only opportunities that follow from the record are listed. Each names the constraint that makes it real.

OpportunityWhy it is genuineConstraint / risk
Org policy mod as a productThe admin page ships a working, documented policy-mod pattern with a real API (plugin.register, e.tier, e.uses.calls, fs.write), a test kit (claude plugin test) and generated typesAnthropic could absorb most of it as a first-party built-in, as it did with sec-default
Mod supply-chain scanning / CI gateclaude plugin validate emits machine-readable hooks:, calls:, env reads:, state reads: lines — a ready-made CI input; and the documented blind spots (rewrites via next, fetch-then-run, --plugin-dir) are a product specThe output is not a promise; a clean report does not prove safety
Vertical mods (regulated-industry change control, data-platform migration assist, incident-response runbooks)Anthropic names CI/CD status, production-touch confirmation and audit logging as the intended team uses; these are exactly the workflows enterprises already buy tooling forEach is a thin wrapper unless it owns real data or real systems
Mod authoring as a serviceplugin-authoring plus hot reload genuinely lowers the skill floor; organisations will want mods built against their own permission and audit policyA services market on a 1-2 year-old, explicitly unstable API
Enterprise mod marketplacesHost-marketplace plus prependPlugins/org-tier classification is a documented, supported patternRequires device management and admin-writable directories on every machine
"Extend the agent" consulting / trainingThe barrier dropped from "shell scripting + JSON" to "TypeScript with generated types" — a large addressable population of devs and a large volume of new controls to designZero defensibility; it is a moving API

Not claimed: any revenue figure, adoption number, or third-party market share. None was found in any retrieved source, and none is asserted here.

Unverified / rumour sources: none used. No leak, anonymous sourcing, unattributed figure or unconfirmed claim is load-bearing anywhere in this artifact. Where third-party findings are pre-release (Pluto Security) they are labelled EARLY RESEARCH and their version is stated.


Hands-On
Hands-on recommendation

The local Claude Code on this machine is 2.1.70, far below the v2.1.287 required for mods, so a BUILD/TEST lab was not possible. Instead I did the verification that mattered: retrieved Anthropic's own generated TypeScript declarations from the shipped repository and extracted the complete event namespace from them, then cross-checked every capability claim in the launch post against the documentation page that governs it, and cross-checked the trust claims against an independent security tester's hands-on findings.

Recommended hands-on for a reader with Claude Code ≥ 2.1.287 (about 45 minutes, in a throwaway repo):

  1. Inspect before you run (5 min). Write a deliberately alarming mod — a tool.call hook on Bash that denies rm -rf, a ui.render hook on AbovePrompt drawing a line, and a tool.check hook that denies while git branch -show-current is main. Run claude plugin validate./my-mod. Read the hooks: and calls: lines. Notice what is listed and what is not: the next rewrites are invisible.
  2. Load and observe (10 min). claude -plugin-dir./my-mod. Watch /plugin report the mod, the band appear, and the counter-style state survive a hot reload — then deliberately break state by keeping it in a module variable, and move it to $.state.
  3. Test before you trust (10 min). Add tests/my-mod.test.ts using claude-code/testing; fire $.tool.call({tool:'Bash', command:'rm -rf /'}) and assert the denial text. claude plugin test. No session, no network.
  4. Check the boundary (5 min). Try to hook the permission prompt's rendering. It cannot be done. Then check tool.check — it can. Sit with that asymmetry.
  5. Audit your own fleet (15 min). Clone each installed plugin's repo and run claude plugin validate on each. Look specifically for $.http.fetch together with $.process.run.

The one habit that matters: install mods the way you'd install code, not the way you'd install a prompt. Anthropic, the docs, the independent analyst and the independent security tester all say the same sentence.

--

↗

What happens next?

🎓 For Explorer

FACT — already committed by Anthropic. "We plan to move more built-in features to mods over time, so you can pare Claude Code down to a small core and add back only what you want." Source for diff, agents-md, sec-default and telemetry is already public in the repository.

FACT — already shipping in the same release. The opt-in built-in mod cc-plugin-you-should-know, "a side agent that watches your back while Claude works on longer tasks", enableable with /plugin enable cc-plugin-you-should-know@builtin, off by default, not stoppable by the settings switches.

PREDICTION (clearly separated from the record):

  1. Capability disclosure moves into the install flow. The gap is documented, specific, and embarrassing for a launch whose headline is "mods can read your secrets"; expect plugin details to start counting function-hook events and the capability list to appear at install within one to three releases. Confidence: moderate-high.
  2. A integrity-pinning or signed-fetch mechanism appears for $.http.fetch, because fetch-then-run is the specific hole that turns "review the plugin" into "review the publisher". Confidence: moderate.
  3. Two to five first-party built-in features migrate to mods over the next two quarters, most plausibly status-line and session-telemetry-adjacent surfaces. Confidence: low-moderate.
  4. Competing coding agents ship in-process extension models with an explicit governance story. Confidence: moderate.
  5. First publicly reported malicious mod. Confidence: moderate; timing unpredictable. It will likely arrive via a marketplace rather than --plugin-dir, and will likely be a UI or transcript deception rather than a loud exploit, because that is the failure mode the platform does not defend.
  6. An enterprise norm forms around policy mods, with allowManagedModsOnly plus a prepend-tier guard as the reference pattern. Confidence: moderate.

★

Editorial takeaway

🎓 For Explorer

The one line: Anthropic turned Claude Code from a product you configure into a runtime you extend — and, in the same move, moved the third-party software supply chain from the outside of the agent to the middle of its permission loop.

The thing most coverage gets wrong: it reports "mods are hooks under the hood" as a naming footnote. It is the architecture. Every capability that matters — rewriting a prompt, deciding a permission, redacting a tool result, redrawing the screen — exists because the handler moved from a separate process exchanging JSON into the engine's own event loop. That single move is what makes the feature powerful and what makes it dangerous, and they are the same fact.

The thing most coverage also gets wrong: treating "unsandboxed" as a footnote caveat. It is the design. Anthropic chose to ship in-process code that runs with the user's credentials, default-on, one day after promising users it would let them install code the way they install any code. The mitigation is real — a guard mod, an allowlist, a static capability scan, a policy-mod language — but it is a process answer to a code problem, and process answers are what fail.

The beat to hold: the capability scan sees API calls. It does not see rewrites, narration, or code fetched later. So a mod that looks clean in claude plugin validate can still change what the user sees about what the agent did. That gap — between what is disclosed and what is done — is the durable story here, and it will outlive the launch.

The genuinely new thing for a beginner audience: you no longer configure an agent. You write a program that runs inside one, in TypeScript, with real types and a real test runner, and then someone else can install it without you reading it. That is a browser-extension-sized decision being made inside a terminal window, roughly once a day, by someone who was told to try a plugin someone posted.

Research sources

Primary Sources (9)
Primary
Claude Code release v2.1.287 — anthropics/claude-code (GitHub Releases) - **URL:** https://github.com/anthropics/claude-code/releases/tag/v2.1.287** The date and the shipped version. Confirms the tag `v2.1.287`, published by `ashwin-ant`, "released this **01 Oct**", commit `816ec21`, and the first changelog line "**Added Claude Mods: plugins may now modify deeper behavior**". Also confirms the same release added "You should know, a built-in mod where a side agent watches your back and flags things you or Claude might miss. Turn it on with `/plugin enable cc-plugin-you-should-know@builtin` (for first-party sessions with telemetry on)", added `prompt_text` to the OpenTelemetry `user_prompt` event, and added URL prompts from MCP servers on the 2025-11-25 protocol. This is the independent-of-blog confirmation that the announcement and the release are the same 2026-10-01 event, and it is the source for the built-in `you-should-know` mod and its default-off/scope caveat. — ** Primary release artefact. Authoritative for the version, the release date and the changelog line. Retrieved in full. - **Retrieval note:** the GitHub **releases index** page was also used indirectly via an indexed search result to locate this tag URL; the evidence relied on in the research artifact is from the tag page retrieved above, not from the index snippet. ---Date: 2026-10-01
URL unavailable
Primary
Claude Code function-hook type declarations — `mods/types/claude-code.d.ts`, anthropics/claude-code - **URL:** https://raw.githubusercontent.com/anthropics/claude-code/main/mods/types/claude-code.d.ts** **Independent verification of the type-definition claim at the source-code level.** This is the declaration file Anthropic's own documentation tells mod authors to read online. Confirms: the file header "**// Written by Claude Code 2.1.277.**"; "EARLY ACCESS: this surface may change between releases without notice"; "Written by `/plugin-types`; regenerate with that command after an update rather than editing. The first line names the Claude Code version that wrote it. TypeScript 5.4 or newer reads it."; that `claude plugin validate <dir>` "is the other half"; the runtime environment ("no DOM, no Node… no `require`"; module suffixes `.ts, .tsx, .jsx, .js, .mjs, .cjs, .mts, .cts`); that elements come from `$.ui.resolve(e)`, not globals; the `'claude-code/testing'` kit and its `$.ui.mount` across the `terminal` / `desktop` / `vscode` / `mobile` surfaces; a ready-made `tsconfig.json` with `"jsx": "react"`, `"jsxFactory": "h"`, `"types": []` and the note that `lib` "names no DOM: the environment has none, and its `Text` would shadow the element"; and the third-party-API pattern ("A plugin that adds a noun to `$` ships its own contract… with no import or reference… the way a jQuery plugin types `$.fn`"). **The declared event namespace was extracted from this file** and is reproduced in the research artifact: `tool.call`/`tool.check`/`tool.register`/`tool.list`/`tool.describe`; `prompt.submit`/`compose`/`edit`/`fill`/`read`/`section`/`context`/`suggest`/`attachment`; `skill.prompt`; `turn.start`/`step`/`complete`/`abort`; `session.start`/`end`/`id`/`cwd`/`root`/`messages`/`usage`/`measure`/`compact`/`attach`/`detach`/`receive`/`send`/`model`/`repo`/`surface`/`surfaces`/`turns`/`version`/`authorize`; `ui.render`/`resolve`/`press`/`input`/`select`/`focus`/`open`/`close`/`panes`/`scroll`/`log`/`message`/`notice`/`toast`/`status`/`invalidate`/`blit`; `command.register`/`run`/`list`/`describe`; `config.list`/`describe`/`set`; `plugin.register`; `engine.create`; `agent.spawn`/`offer`/`register`/`list`; `attribution.text`; plus `ClassicEventOf` as `` `classic.${ClassicHookEvent}` `` and the hookable op events `fs.*`, `process.*`, `http.fetch`, `env.*`, `settings.read`, `store.*`, `clock.*`, `mcp.call`, `model.*`, `audio.*`. Also confirms `EventOf = CoreEventOf & NounEventOf`, `CoreEventOf = EngineEventOf & ClassicEventOf & OpEventOf`, that `CoreEngineInterface` and `EngineInterface` are **empty interfaces** (extended only by plugins via declaration merging), that `$` is frozen, and the tree bounds ("20,000 nodes, 32 deep, 100,000 characters serialized") beyond which the instance unmounts. — ** **Primary technical artefact, read at source.** Independently verifies the "full type definitions" claim, the `next` continuation model, the runtime environment, and — most usefully — the complete event surface, without relying on prose docs. **Caveat carried into the research artifact:** this checked-in copy is a snapshot written by 2.1.277 and still carries an early-access header, whereas mods are GA and default-on in v2.1.287; Anthropic's own instruction is that the per-build generated file is authoritative for your version. - **Retrieval note:** fetched as raw text; the response was truncated in display at 1,312 of 13,186 lines, so the event-name extraction was performed against the full saved output rather than the visible preview.
URL unavailable
Primary
Hooks reference — Claude Code documentation (the existing settings-hook mechanism) - **URL:** https://code.claude.com/docs/en/hooks** The precise answer to "is the existing hooks mechanism replaced or unchanged". Confirms settings hooks are "user-defined shell commands, HTTP endpoints, MCP tool calls, LLM prompts, or subagents"; and the explicit statement: "A plugin can also register hooks as JavaScript functions that Claude Code calls in its own process, which can draw in the interface as well as act on events. A plugin that does is a mod… **The hooks on this page keep working alongside mods.**" Confirms the settings-hook event set and that no part of it is described as deprecated; the five handler types (`command`, `http`, `mcp_tool`, `prompt`, `agent`); the seven hook-definition locations; that `allowManagedHooksOnly` blocks user, project, local and plugin hooks while exempting plugins force-enabled in managed `enabledPlugins`; that `disableAllHooks` in user/project/local settings cannot disable managed hooks; and the HTTP-hook allowlists that apply to hooks from every source. This is the evidence that **settings hooks are unchanged, not replaced Primary technical documentation. Decisive for the Before/Change/After distinction between settings hooks (external) and mods (in-process).
URL unavailable
Primary
React to events with a mod — Claude Code documentation - **URL:** https://code.claude.com/docs/en/plugins/mods/events** The event-handling semantics. Confirms the middleware chain model and that what a hook does with `next` decides whether it observes, rewrites or answers; that the event is "deeply frozen" and assigning to a field throws; the `deny` short-circuit shape (`return { deny: '…' }` with no `next`, so "the command never runs" and Claude reads the deny text as the tool result); matcher semantics (value / array / regular expression) and the wildcard forms `'classic.*'` and `'*'`; registering the same event twice without a matcher failing to load; the `tool.call` semantics including that it fires for subagent calls and MCP tools and that "When you call `next(e)`, Claude Code runs the permission check and then the tool"; retrying a call by calling `next(e)` again on `isError`; holding a call with `await $.ui.ask(...)` and that time spent inside a `$` call "doesn't count against the hook's time limit" while time on the mod's own promise does, and that "Claude Code skips a hook that times out, so the held command would run"; the `tool.check` semantics ("It fires after the permission rules and the settings hooks have decided, and `next(e)` resolves to their decision: `allow`, `ask`, or `deny`"), with the documented example that a `tool.check` hook can override even a rule that allows the call; the `prompt.submit` table (rewrite text / add Claude-only context / `{ drop }`); the `turn.start` / `turn.step` / `turn.complete` table including `turn.step` as an async generator for streaming, `next({ ...e, model })` to route a request to a different model, and the `result.usage` fields; the `classic.Stop` mirror example; **"The order mods run in"** (four numbered tiers; within a tier, load order; a mod before its dependencies); and **"Where settings hooks run in the order"** (managed `PreToolUse` first with a final block; all other `PreToolUse` after the last mod's `next`; `tool.check` after those); and **"Handle a hook that fails"** (fails before `next` → skipped, next handler runs; fails after `next` resolved → that result stands) with the `.catch` fail-closed pattern. — ** Primary technical documentation. Authoritative for the middleware/continuation model, the ordering rules, the settings-hook interaction, and the fail-open default.
URL unavailable
Primary
Mods overview — Claude Code documentation - **URL:** https://code.claude.com/docs/en/plugins/mods/overview** The definition and the comparison surface. Confirms the explicit disambiguation that settings hooks "also run on events, as a shell command, HTTP request, or prompt you configure in a settings file. A mod's handlers are functions that run inside Claude Code instead"; the five things a mod can do that external extension surfaces cannot (draw an interface; redraw Claude Code's own interface; step into a tool call or request; run own code on a command with no Claude turn; share data between hooks); the security warning and the six-bullet "What a mod can reach" list (act as you; read secrets including an API key; see your session; change your session; act without asking; spend your usage); the sandbox carve-out ("If you turn on sandboxing, the sandbox isolates the Bash commands Claude runs, and a process that a mod starts runs outside it"); that a mod approving tool calls can approve one an `ask` rule would prompt for or a `PreToolUse` hook blocked; and "A mod can restyle much of Claude Code's interface, but not the permission prompt. It can't change what a prompt shows you."; the four kill switches and their exact reach, including that built-in mods are **not** stopped by `disableAllHooks`, `--bare` or `--safe-mode`, and that `CLAUDE_CODE_ENABLE_FUNCTION_HOOKS` is ignored from v2.1.287 at any value; `claude plugin validate` as the pre-install inspection step; the three sample mods in `anthropics/claude-code-playground` (`token-weather`, `blast-radius`, `replay-theater`) with descriptions and "shared as they are, without support"; the **"Where mods run"** table (hooks run in terminal / editor integrated terminal / JetBrains plugin / Desktop Code tab / VS Code chat panel / `claude -p` / Agent SDK / Remote Control / cloud session; drawing only in terminal and Desktop Code tab; **no hooks and no drawing in a WSL Desktop session**); the four-column comparison table of mod vs settings hook vs skill vs MCP server; and the **"Mods built into Claude Code"** table naming `cc-plugin-agents-md`, `cc-plugin-diff`, `cc-plugin-plugin-authoring`, `cc-plugin-sec-default`, `cc-plugin-telemetry` and `cc-plugin-you-should-know`, with what each does, where it is on, how to turn it off, and that `cc-plugin-sec-default` "You can't" disable. Also lists which built-in mod sources are public in the repository. — ** Primary technical documentation. Authoritative for the capability list, the runtime-surface table, the built-in-mods inventory and the "not the permission prompt" boundary.
URL unavailable
Primary
Manage mods for your organization — Claude Code documentation - **URL:** https://code.claude.com/docs/en/plugins/mods/admin** The entire enterprise/governance section. Confirms "Mods are on by default in Claude Code v2.1.287 and later"; `allowManagedModsOnly` under `pluginConfigs` keyed by `cc-plugin-sec-default@builtin` and exactly what it blocks and preserves; that the guard loads when the machine has managed settings **or** the user is on Team/Enterprise, and loads otherwise only with managed settings; what the guard protects (managed hook inputs/decisions, system prompt, managed CLAUDE.md and instructions, what any mod reads as settings, managed MCP tool names and descriptions) and that "Everything else is allowed"; deny-rule and managed-`PreToolUse` precedence; the documented gap that "Neither applies to a mod's own `$.fs` and `$.process` calls: with `Read(.env)` denied, a mod can still read that file with `$.fs.read`"; the `allowModsToOverrideDenyRules` option; that a mod can approve a call an `ask` rule would prompt for or a non-managed `PreToolUse` hook blocked, and that in auto mode a mod-approved call "runs without a classifier check"; that the guard fails closed when it cannot read managed settings or check deny rules; the four-setting policy table (`allowManagedModsOnly`, `allowManagedHooksOnly`, `disableAllHooks`, `disableSideloadFlags`) with each one's actual reach; the full worked `managed-settings.json` for "Only your organization's mods"; the three conditions under which a mod counts as your organization's (managed `enabledPlugins` true; managed settings name the marketplace as a **directory by absolute path**; the marketplace lists the plugin by **relative path** so it loads in place), and that a plugin copied into cache counts as a user's mod; the requirement that the directory be admin-writable only; `prependPlugins` / `appendPlugins` semantics and that repositories cannot set them; the complete `acme-guard` policy-mod example using `plugin.register`, `e.tier`, `e.uses.calls`, `tool.call` and `fs.write` with `next.origin.plugin`; the fail-closed `.catch` variant and the stated reason ("if your `plugin.register` hook throws or exceeds its time limit, Claude Code skips the hook, so the check fails open"); the `claude --debug` log lines to confirm each outcome; that a worker thread crashing three times unloads every non-built-in mod; that `--safe-mode` disables org mods too; and the `claude plugin validate` "calls:" table with what each `$.` method means. — ** Primary technical documentation. Authoritative for every governance, control and policy-mod claim in the research artifact.
URL unavailable
Primary
Create a mod — Claude Code documentation - **URL:** https://code.claude.com/docs/en/plugins/mods/create** The authoring contract. Confirms a mod is a plugin with an entry file called the **hooks module**, a JavaScript or TypeScript file whose functions Claude Code calls when events happen; "You don't need Node.js, a bundler, or a build step, because Claude Code loads `.js` and `.ts` files directly"; "**Mods require Claude Code v2.1.287 or later**"; the `plugin-authoring` built-in skill and `/plugin-authoring`; the `~/.claude/dev-mods/<session-id>/<mod-name>/` location for Claude-written mods; the four conditions where a Claude-written mod does not load (nobody there to approve — `claude -p` / `dontAsk`; workspace not trusted; mods disabled via `--safe-mode` or `--bare` or `disableAllHooks` or org managed settings); the three-file example; the full `register(on)` example with `session.start`, `tool.call`, `command.run{command=tally}` and `ui.render{component=Spinner}`; the three hook arguments (`$`, `e`, `next`); **the type-definition mechanism** — declaration files ending `.d.ts` written into `.claude-plugin/types/` on each load/reload, listing `claude-code/index.d.ts`, `claude-code-tools/index.d.ts`, `claude-code-mcp/index.d.ts`, one directory per dependency plugin, and `tsconfig.json`; "If your mod has no `tsconfig.json` of its own, Claude Code adds one at the mod root that extends the generated one, so your editor and `tsc -p ./first-mod` type-check the mod without more setup"; and the normative instruction "**The events and methods can change between releases, so trust these files over any page, this one included, when they disagree.**"; the `claude plugin validate` output format (`hooks:`, `calls:`, `env reads:`, `env writes:`, `state reads:`, `state writes:`); the static-analysis rules (fully-qualified `$` calls, string-literal event names, no shadowed `on`, relative imports only with bare `claude-code` allowed, `import` not `require`, ES modules only); the `claude plugin test` harness and `claude-code/testing`; and the naming rule that `claude plugin validate` fails a name that looks like one of Anthropic's own, "such as one that starts with `claude-`". — ** Primary technical documentation. The source of truth for the authoring, type-definition, validation and testing claims in the research artifact.
URL unavailable
Primary
Getting started with Claude Code mods — Anthropic developer blog (full URL below), author Addy Osmani - **URL:** https://claude.dev/blog/getting-started-with-claude-code-mods/** The practical, worked version of the feature. Published **Oct 01, 2026**. Confirms "**Claude Code 2.1.287 or later.** Mods are on by default, so there's nothing to turn on."; that "the API can change between releases" and that the per-build generated declarations are "the authority for your version"; the file layout (`plugin.json`, `hooks/hooks.json` with `modules`, the hooks module exporting `register(on, options)`); the three-move table (Observe / Rewrite / Answer) with `next(e)`, `next({...e, command: safer})`, and `return { deny: "…" }`; the runtime constraint ("The module runs in a sandbox of its own, with no DOM and no Node, so everything outside it goes through `$`"); the contrast with settings hooks (a mod is loaded once and stays in the session, keeps state, draws UI, and can call back into Claude Code); that "**Claude Code uses them itself**" — AGENTS.md support and the `/diff` pane are built-in mods whose source and tests are public under `mods/` in the public repository; the `AbovePrompt` component and `$.ui.resolve(e)` for surface-specific element constructors; `$.session.usage()` for context figures; why state belongs in `$.state` (hot reload is a fresh load, module variables reset); the `types/index.d.ts` + `interface PluginState` contract required by `claude plugin validate`; the full "Token Weather" module; `claude plugin validate` output including `state reads/writes` lines; `claude plugin test` against the real runtime with no session, sign-in or network; marketplace sharing; the trust framing ("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"); the "Blast Radius" sample (holds `rm -rf` / `git reset --hard` / `git clean` / force push / DB migration, opens a Pane with Proceed/Cancel, degrades to the band when a pane will not fit, and the explicit caveat "It's a safety net, not a permission system… Use permission rules for a hard block"); and "Replay Theater" (observes Edit/Write, `/replay` command). — ** Primary technical tutorial by an Anthropic-authored engineer blog. Supports the concrete API shape, the version requirement, and the built-ins-are-mods claim. Its security caveats are labelled as the author's own framing.Date: 2026-10-01
URL unavailable
Primary
Customize Claude Code with mods — Anthropic blog post (full URL below) - **URL:** https://claude.com/blog/claude-code-mods** The launch itself. Confirms the product post is titled "Customize Claude Code with mods", is categorised "Product announcements / Claude Code", and is dated **October 1, 2026**. Confirms the definition ("small TypeScript functions that change how Claude Code works"); that a mod can rewrite a prompt, add new UI, replace a built-in feature or add new functionality; that mods ship inside plugins and work in the CLI and desktop app; the security admission ("Mods run with the same access to your machine as Claude Code itself. They aren't sandboxed, and you should only install mods from sources you trust"); the stated reason for building them ("Hooks helped give users some of this control, but hooks can't rewrite events, draw new UI, or replace features. Mods can."); that the design was shared on GitHub before launch; the mechanism description (Claude Code emits an event; a mod hooks into it; a mod can run before, after, or instead of the event, or wrap it); the four headline capabilities (rewrite a prompt before it reaches the model; block, rewrite, or retry a tool call; approve or deny a permission request; redact secrets from tool output before Claude reads it); UI replacement of parts Claude Code draws; load-order composability ("The first mod to load sees the event first and the result last"); that Claude can write a mod for you and hot-reload it in-session; that `/diff` is now a mod that can be turned off in `/plugin` or replaced, with the plan to "pare Claude Code down to a small core"; the enterprise section (existing plugin controls apply; admins allow/block marketplaces; owner sets this in the admin console on Team/Enterprise; managed settings pushed on Claude API and third-party API plans); `sec-default` ("security default") loading first on Team/Enterprise and on any machine with managed settings, stopping user-installed mods from "overriding your permission deny rules", with source viewable; and the three team use cases (CI/CD status pane, production safeguards confirmation, audit logging a mod that loads first). — ** Primary company source. Authoritative for what was announced and claimed. Marketing-adjacent framing is labelled COMPANY CLAIM where used. — ** The blog's own links point at `https://claude.dev/blog/getting-started-with-claude-code-mods/` for the tutorial and `https://code.claude.com/docs/en/plugins/mods/overview` for the docs. Both were retrieved (items 2 and 5). The blog's link to the design issue is `https://github.com/anthropics/claude-code/issues/91870` (item 8).Date: 2026-10-01
URL unavailable
Independent Sources (4)
Independent
Inside Claude Code Function Hooks: The Trust Problem Behind Claude Mods — Pluto Security (Ehud Melzer) - **URL:** https://pluto.security/blog/claude-code-function-hooks-security/** Independent hands-on security testing — **of the pre-release build**, and labelled EARLY RESEARCH throughout the research artifact. Confirms the test target (screenshots from **v2.1.274**, gated behind `CLAUDE_CODE_ENABLE_FUNCTION_HOOKS=1`) and the four findings: (1) silent exfiltration — a `user`-tier mod read `~/.claude/.credentials.json` and an 834 KB `history.jsonl` of every prompt across every project and POSTed them out with `$.http.fetch`, with "`$.fs.read` **not scoped to your project or your session**" and "No prompt appeared. No permission was asked."; (2) no capability disclosure at the decision point — install prompted nothing and `plugin details` reported a four-event wildcard mod as "**Hooks (0)**" while a classic hook plugin showed "Hooks (1) PreToolUse", with the capability list appearing only under manual `claude plugin validate`, and the content scan tied to the claude.ai channel so `--plugin-dir` and self-hosted GitHub marketplaces bypassed it; (3) UI spoofing — a fake "Anthropic – session verification required / re-enter your API key" prompt drawn in the `AbovePrompt` band and exfiltrated on submit, and a `ui.render` hook that swapped a genuine `AskUserQuestion` dialog's text so the user read "Refresh the local build cache now?" while the model received "Confirm" against "Delete ALL files in ~/prod-data permanently?" — **plus their own stated limitation** that the engine preserves model-authored option labels, so descriptive labels are restored but generic "Confirm"/"Cancel" are not; and a two-hook transcript falsification performed "without a single `$` call", so `claude plugin validate` "sees a mod that appears to do nothing"; (4) fetch-then-run — serving a benign script then swapping the served file "**without changing the mod**: no new version, no reinstall, and no new review", with the conclusion "`$` can tell you that a mod *can* fetch data and run a shell. **It can never tell you what it fetches or runs.**" Also the four controls that worked (ambient access blocked; the permission prompt's display not rewritable; `AskUserQuestion` labels preserved; tier identity host-attributed and not spoofable), and the recommended remediations. — ** **EARLY RESEARCH.** Strongest available independent security evidence, but explicitly pre-GA and version-specific. Every finding is carried into the research artifact with its date, its tested version, and an explicit statement that it is **not** established as current v2.1.287 behaviour. The article itself carries a "Pre-release note". - **Gap recorded:** no post-GA independent security assessment of Claude Code Mods was retrievable within this research. No mainstream technology outlet published dedicated hands-on reporting on mods within the research window that could be retrieved. ---Date: 2026-09-22
URL unavailable
Independent
Claude Code 2.1.287 adds mods, and Anthropic says they can read your API key — MIXED (Shane S. Ellison) - **URL:** https://mixed-news.com/en/claude-code-2-1-287-mods-not-sandboxed-api-key/** Independent reporting, and the one independently established **rollout gap**. Confirms Anthropic "published Claude Code 2.1.287 to npm on October 1 at 16:59 UTC"; the changelog line "Added Claude Mods: plugins may now modify deeper behavior"; quotes the docs' own "read your secrets: environment variables and settings files, including an API key you keep in either"; confirms the sandbox carve-out and the single boundary that "A mod can restyle much of Claude Code's interface, but not the permission prompt. It can't change what a prompt shows you."; independently restates the three kill switches and `allowManagedModsOnly`; and records the load-bearing distribution fact: "**Checked on October 2, the npm registry still pointed its stable tag at 2.1.285, with latest and next on 2.1.287, so a machine following the stable channel does not have mods yet.**" Also confirms Claude Code 2.1.286 shipped 2026-09-30 with fixes to how Claude Code redacts secrets, and restates the three playground sample mods. — ** Independent reporting within the window. Sole source for the npm stable-tag rollout gap, which is used in the research artifact as INDEPENDENT EVIDENCE and is attributed to this outlet. The npm registry check is this outlet's own observation, not Anthropic's statement.Date: 2026-10-02
URL unavailable
Independent
Claude Code Mods: Plugins That Run Inside the Agent, With Your Permissions — independent technical blog (full URL below), author Florent Clairambault - **URL:** https://sdd.sh/2026/10/claude-code-mods-in-process-plugins-v2-1-287/** Independent practitioner analysis and one independently confirmed release fact. Confirms "**Claude Code v2.1.287 (Oct 1) ships mods**"; that mods are "on by default, unsandboxed, and run with your user permissions"; that before mods every extension point was external; that "the two hooks share module-level variables, which is the quiet superpower here: state flows between handlers without files or IPC"; that `blast-radius` is "a policy engine you write in twenty lines"; the independent judgement that "Terminal-native agents have always had one honest weakness against IDE wrappers: UI" and that "Mods hook the agent loop itself, which is where autonomy gets shaped"; the recommendation to "Treat `/plugin install` like `npm install` from an unknown publisher, because that is what it is"; the four practical hygiene rules (audit with `claude plugin validate`; know the kill switches; for organisations, decide the policy this week; write them with Claude); the note that `cc-plugin-sec-default` cannot be disabled by users; and the closing verdict: "They also change your threat model overnight, and the default-on rollout puts the burden on you." — ** Independent technical commentary / interpretation. Used for framing and for the independently corroborated v2.1.287 / Oct 1 pairing. Its claims are labelled INTERPRETATION in the research artifact, not upgraded to fact.Date: 2026-10-02
URL unavailable
Independent
Mods - make Claude 10x more extensible · Issue #91870 — anthropics/claude-code (GitHub) - **URL:** https://github.com/anthropics/claude-code/issues/91870** The pre-launch timeline and the architecture admission. Confirms the issue was **opened 2026-09-03** by `poteat` with labels `area:hooks`, `area:plugins`, `enhancement`, and that it carries a linked technical architecture PDF and nine demo videos. The **2026-09-09** community update is the key text: "We're shipping in N weeks"; "we are going to be calling this functionality 'Claude Mods'. The engineering term of art 'function hook' will still exist as the documented implementation primitive Mods are built on. **A mod is just a plugin that uses function hooks, nothing is changing there.**"; "we've made available our source listings for our first three built-in mods"; "Our intent is to take further extant features as they exist in CC today and migrate them to mod form"; and that early testers could use `CLAUDE_CODE_ENABLE_FUNCTION_HOOKS=1 claude`, with affordances enumerated for v267/v268. The **2026-10-01** update reads "We're live!". The original post is the source of the design rationale: "we could hook into CC using TypeScript functions a la Express (or Koa!), and basically change whatever you want"; "In the workplace, admins will be able to change what they want too, including *your* ability to change things"; "You should even be able to modify how components get rendered. We use React across the board, so why not utilize that fact?"; "Algebraically, this is just an effect-parameterized endomorphic continuation model for plugins"; and the discovery phrasing "We introduce the ability for hooks to be TypeScript functions, with full type definitions and LSP support." — Primary for design intent and timeline; reclassified 's "independent" placement because it is Anthropic-authored.** It is nonetheless the single most useful non-documents artefact for S12, because it contains the pre-launch commitment and the explicit statement of what "mod" is. The individual commenter activity on the thread was not retrieved or relied upon (GitHub served the shell without the comment list); **no third-party commenter claim is used anywhere.**Date: 2026-09-03 (opened); last activity 2026-10-01
URL unavailable
Secondary Sources (2)
Secondary
Secondary/aggregator items not used The following appeared in indexed search results and were deliberately **not** used as evidence, because they are AI-generated summaries, unretrieved in full, or duplicate items 11–13: `https://news.bpdata.com/article/claude-code-now-modifiable-with-modular-plugins-86035e19` (self-described "Articles are generated by AI from public sources"), `https://blog.4sapi.com/blog/claude-mods-typescript-hooks-developer-guide` (dated 2026-09-15, i.e. pre-launch, and partly non-English formatting), `http://ai-tldr.dev/releases/anthropic-claude-code-2-1-287/`, `https://techaiwire.com/articles/claude-code-2-1-287-claude-mods-you-should-know/`, `https://deployedbyai.com/log/df8de57eb4e5/claude-code-v2-1-287/?k=br`, `https://www.havoptic.com/r/claude-code-2-1-287`, `https://www.aitmpl.com/mods`, `https://aihot.cataito.com/en/daily/2026-10-03`, `https://dev.to/pawel_nowak/i-built-my-first-claude-code-mod-without-writing-code-claude-wrote-it-validated-it-and-2mh7`, `https://dev.to/reporails/claude-code-mods-minesweeper-and-testkit-3067`, `https://dev.to/hiroki-ii-ai/claude-code-v21287-skills-instruct-mods-decide-3j08`, `https://dev.to/sarantoon/claude-mods-khuueaair-claude-code-epidaihkhunaetng-coding-agent-aidengaelw-2dd0`, `https://dev.classmethod.jp/en/articles/20261002-cc-updates-v2-1-287/`, and `https://simonwillison.net/tags/llms/` (whose 2026-09-18 entry quotes Shihipar that "AGENTS.md support is built off of Claude Code mods, our upcoming way to customize the Claude Code harness" — corroborative of item 5's built-in-mods table, but the page was **not** retrieved, so it is not cited). Listed here only so the omission is auditable. ---
URL unavailable
Secondary
Anthropic Launches Claude Code Mods for User Customization — HuggingNews - **URL:** https://huggingnews.com/ai/anthropic-launches-claude-code-mods-for-user-customization-d913b016** Same-day aggregator record and one attributable executive statement. Confirms the 2026-10-01 date and summarises the announcement (behaviour, UI and functionality changeable via TypeScript plugins; installed with `/plugin` in the desktop app or CLI; writable by hand or generated by prompting Claude). Its value is the attributed quotation it carries from Anthropic's `@claudedevs` account ("You can now mod Claude Code: - Change how it behaves - Customize the UI - Swap in your own features") and from **`@trq212` (Thariq Shihipar)**: "**all software is becoming malleable, so it was important for us to support this as a first class citizen in Claude Code**" — the origin of the "first-class citizen" framing. The page also links the source posts. — ** Secondary aggregator of company social posts. Used only for the same-day date confirmation and the attributed Shihipar statement, which is reported speech and is labelled as such. No capability claim rests on this source.Date: 2026-10-01
URL unavailable