Everything Is Pluggable
Six rings snap onto a core that never moves. Around two dozen named moments in a session hand control to your own code. Every piece carries a tag naming where it came from.
Before we asked what the model can do. Now we ask what you snap on, and where your code runs once you do.
Plugin stack
A LEGO set has one solid piece in the middle. That piece never changes, and it runs everything.
Studs ring that piece. You snap on a new action, a saved routine, a bridge out, or your own code at one moment. Pieces come off as easily as they go on.
The middle keeps working the same way. New powers on the outside, untouched core in the center. That is what extensible means.
Hooks surprised me most of the six. Each named moment in a session is a place your code steps in. One session runs below. Step it forward and read what each moment hands your code.
01Six layers, not one plugin slot
Six kinds of snap-on piece took me a while to see. Each ring buys a different power. Altitude sets the order: hooks sit closest to the loop, output styles furthest out.
commands
the slash menu
Things you type. Adds menu actions, gated by feature flags, account type, and web or API.
skills
markdown + a header
Prompts the model can invoke. Adds reusable workflows that run inline or as a forked worker, with their own tools and effort.
MCP
the bridge out
A protocol to the outside. Adds external tools, files, and prompts, picked per agent and connected over a few transports.
plugins
a package
A way to ship the rest. Adds bundles of skills, hooks, and external connections from one manifest.
hooks
two dozen moments
Lifecycle wiring. Adds code at defined moments that can allow, deny, rewrite input, add context, or refuse a stop.
output styles
the voice
Response shaping. Adds a formatting instruction, with the option to keep the core coding guidance intact.
02Commands are a gated menu
The slash menu ships in two halves. Many actions are always there. A command in the other half sits behind a feature flag, an inside account type, or a demo exclusion. One more gate shows it only on the web or only on the API.
The same gating rule shows up all over. A piece sits in the box, and who you are decides whether you can pick it up. A command also declares whether it runs in place or forks a subagent. The menu reads what you type and what the model asks for.
03Skills are a prompt with a header
A skill is a markdown file with a short header. The header decides what the skill does, when to use it, and who can call it. It names the tools the skill reaches and the model that runs it. Two more lines set where the skill runs, in place or as a subagent, and which files wake it up. Match those files and the skill appears only near relevant code.
The model reaches a skill through one tool. That tool opens the skill into the chat, or runs it as a subagent with its own budget. A subagent loads its skills by name before it starts, the same scoping the scheduler piece set out.
04MCP is the bridge to everything else
MCP is the bridge out. Connect an outside server, and its tools, files, and prompts land in the same menus as your own. One tool calls the server's tool, and others browse and sign in. Each agent carries its own set of bridges, so a subagent holds a different set than its parent.
05Plugins package the rest, read carefully
A plugin ships as one bag under one manifest. Install it and its hooks join the shared pile at session start.
A careful claim
In the implementation snapshot behind this essay, the box of built-in plugins is empty. The machine to hold them is built, the shape and the loader, and no bags ship inside it yet. So the honest claim is narrow. Plugins are a real way to load skills, hooks, and outside bridges from one bag. This snapshot shows no stocked store. Saying only that, and no more, is the gap between knowing how a thing works and guessing.
06Hooks are where your code joins the loop
A hook fires at a named moment and runs one of three ways. The three ways are a shell command, a call to another service, or an inline decision. The moment then decides what the hook returns: allow, block, rewrite the input, or add context.
Pick a moment in the figure below and press each decision. A struck-through decision is one that moment refuses to return. The stop refusal is the "go again" call from the first idea in this guide. It is one of the endings that piece told you to name.
the moment that fired
what this moment lets a hook return
Press a decision above. The same hook can only return what this moment allows.
The named moments do not all fire in one session. A file changing or a workspace being made needs a watcher or a feature switched on. The list is the full set of places your code can run.
The cost
Six rings overlap, and the overlap is where it bit me. A plugin carries skills and hooks, a skill adds hooks, and an outside prompt reads like a local skill. A command is almost a skill wearing a different coat. The freedom to mix costs you a clear answer about where a behavior came from. A source tag rides on every piece, so the system points at the command, skill, or hook behind it. Snap on your own pieces and that tag walks a bug back to the right one.
Decision
Pick the smallest piece that does the job. A prompt you reuse is a skill, one file and a header. A guard on a tool's input is a hook, one moment and one decision. An outside system is an MCP bridge, one connection. Spend the cheap move first, the same rule the previous piece ran on primitives.
Two checks run before I build. Name the one ring the change belongs to, and name what fires it. A change across three rings is two changes wearing one name. The next idea walks the half-built corners of the product and the parts they reuse.