Skills, hooks, plugins, and mods: how to customize Claude Code (and what Cursor and Codex offer)

Claude Code used to feel like a powerful agent with a few toggleable extras. In late 2025 and into 2026 it grew a clearer stack of customisation layers. Then on 1 October 2026, Anthropic shipped mods: small TypeScript (or JavaScript) modules that can rewrite prompts, guard tool calls, or draw their own UI.

If you are learning with Buildcamp's course agents (Claude, Codex / ChatGPT, and Cursor including Grok), you do not need every layer on day one. This post explains the four Claude Code layers in plain English, gives a beginner decision table, and points at the closest Cursor and Codex equivalents. Deep how-tos already live in our guides; link those instead of reinventing them.

Verified against: Anthropic's Getting started with Claude Code mods (Addy Osmani, 1 Oct 2026), the Claude Code mods announcement, and the Claude Code changelog for v2.1.287+. Features and APIs can move between releases, so re-check /plugin and claude --version when you try this.

The four Claude Code customisation layers

Think of them as a ladder. Start low. Climb only when a lower layer cannot do the job.

1. Skills: reusable instructions

A skill is a packaged set of instructions (often a SKILL.md plus optional scripts or references) that teaches Claude how to do a specific kind of work: review a PR, ship a Stripe Checkout, follow your team's deploy checklist.

You invoke skills with /, or Claude can pick them when the task matches the skill description. Skills are great when you want the same playbook available across sessions without pasting a long prompt every time.

Skills do not rewrite Claude Code's internals. They load guidance into the conversation.

2. Hooks: scripts on events

A settings hook is a shell command Claude Code runs when something happens (for example before a tool runs, when a session starts, or when a turn ends). The event payload usually arrives as JSON on stdin; your script answers on stdout.

Hooks are the right tool when you want automation at the boundary: block a risky pattern, run a formatter after edits, or log what happened. They are event scripts, not a full in-session UI framework.

Anthropic also distinguishes these from mod hooks: a settings hook spawns a shell each time; a mod stays loaded in the session and can keep state and draw UI.

3. Plugins: installable bundles

A plugin is the installable package. It can ship skills, hooks, MCP servers, slash commands, and (now) mods. You install from a marketplace or a folder with `/plugin(or the CLI equivalents), then reload.

If you want to share a workflow with a teammate, you usually package it as a plugin. Buildcamp already covers packaging and Supabase-related agent plugins in more depth in Practical guide: Agent Plugins with Supabase.

4. Mods (new 1 Oct 2026): deeper behaviour+UI

A mod is a small TypeScript or JavaScript module that runs inside your Claude Code session. Under the hood, mods are hooks that ship inside plugins. Each mod exports something likeregister(on, options)` and listens to session events.

In plain words, a mod can:

• Observe an event (watch tool calls, measure context use)
• Rewrite what the rest of the chain sees (nudge a prompt, adjust a command)
• Answer instead of letting Claude Code continue (deny a tool call, serve a custom command)
• Draw UI (a band above the prompt, a side pane, buttons)

Anthropic's own examples include Token Weather (context forecast above the prompt), Blast Radius (hold risky Bash and show what it would touch), and Replay Theater (step through the last turn's file edits). Some Claude Code features, including AGENTS.md support and the /diff pane, are themselves built as mods in the public anthropics/claude-code repo.

Requirements: Claude Code 2.1.287 or later. Mods are on by default.

When to use which (beginner table)

Honest curriculum take: most Buildcamp students only need CLAUDE.md or AGENTS.md plus a couple of skills. Hooks help when you have a clear automation. Mods are powerful and new; try them after the basics feel boring, not before.

For the instruction-file layer, use:

• The Ultimate Guide to CLAUDE.md in 2026
• One AGENTS.md for Claude Code, Codex, and Cursor

Easiest first try: enable You Should Know

Anthropic ships a built-in mod called You should know: a side agent that watches your back and flags things you or Claude might miss.

In Claude Code (first-party sessions with telemetry on), run:

/plugin enable cc-plugin-you-should-know@builtin

That is the lowest-friction way to feel what a mod does without writing TypeScript.

Or ask Claude Code to write a small mod. Start claude, allow hot reload when it asks, and describe what you want in plain English (for example a context-window weather band above the prompt). Anthropic's tutorial shows that Claude Code already knows how to scaffold mods; you do not need to memorise the API for a first experiment. Copy the folder out and install it like any plugin if you want to keep it.

Safety: treat mods like code you run on your machine

Anthropic is explicit: a mod runs inside Claude Code on your machine, with the same practical access Claude Code has (files, processes, network through the mods API). The publisher, not Anthropic, wrote that code.

Practical rules:

1. Only install mods and plugins from sources you trust.
2. Read the repo before you /plugin install.
3. Prefer built-ins and first-party marketplaces while you are learning.
4. Remember: a "guard" mod that classifies command text is a safety net, not a hard permission system. Keep Claude Code permission rules for hard blocks.

This is the same hygiene you already use for shell scripts and npm packages. Mods are just closer to the agent loop.

Short Cursor and Codex equivalents

Buildcamp teaches three agent surfaces. Here is the rough map, not a feature-for-feature mirror.

Cursor

• Project rules / AGENTS.md-style guidance: Cursor rules and shared instruction files (see the AGENTS.md guide above).
• Skills: Cursor Agent Skills (SKILL.md folders under .cursor/skills/, .agents/skills/, and compatible Claude/Codex skill dirs).
• Pin a skill for the whole session: use a skill as a Custom Mode. In the Agents Window, type `/, highlight a skill, then Option+Enter (Mac) or Alt+Enter (Windows/Linux), or choose Use as Mode. Normal Enter applies the skill to one message only; a mode keeps it on until you exit or switch.
• Plugins: Cursor supports Agent Plugins and Cursor Plugins (skills, MCP, rules, agents, commands, hooks). Browse Customize / Marketplace rather than inventing a Claude Code mod clone on day one.

Codex / ChatGPT

• Persistent project guidance:AGENTS.md` (Codex reads it before work; keep it small).
• Skills: Agent Skills with SKILL.md; author locally, invoke with $ / `/skillsin Codex.
• Plugins: the installable distribution unit for skills (and often connectors / MCP). Skills author the workflow; plugins ship it.

None of these replace Claude Code mods one-for-one today. The shared beginner path across all three is still: clear instruction files+a few skills, then packaging, then deeper runtime hooks when you have a real need.

For connecting agents to your backend tooling, you may also like MCP servers are changing the game for AI tools and the Agent Plugins with Supabase guide linked earlier.

A sensible learning order

1. Write a shortCLAUDE.mdorAGENTS.md` for one repo.
2. Add one skill for a workflow you repeat weekly.
3. Enable You Should Know if you are on a supported Claude Code build.
4. Only then ask Claude Code for a tiny mod, or install a plugin you have actually read.

Emerging concepts move quickly. Treat mods as an exciting optional layer, not homework for week one. Master the instruction files and skills first, then customise deeper when the agent is already earning its keep.