Over the last few weeks I’ve used Claude Mods to adapt Claude Code to my AI engineering workflow. Claude Code is useful out of the box, but each engineering workflow is different — Claude Mods let you make Claude Code behave in the way you want to direct your attention.
The key idea is attention. In a recent Latent Space post, "The Evolution of the Agent Harness," the author argued that as models internalize more of the harness into their weights, the remaining harness becomes oriented toward humans: the Attention Interface, the layer that decides when the agent interrupts you, what it shows you, and which decisions it requests from you. Claude Mods are an early, user-shapable implementation of that interface.
What is a mod?
A mod is a Claude Code plugin composed of TypeScript or JavaScript functions that run inside Claude Code. These functions customize the behavior and appearance of the interface in both the CLI and the Desktop client. Mods respond to events — for example a prompt, a tool call, or a render — and can observe the event, change how it is rendered, and handle it instead of the default behavior.
Technically, Claude Mods act as middleware for the agent harness: they inject code that alters Claude Code’s execution and rendering flows, changing the application’s runtime behavior.
Crucially, mods let the human and the agent jointly build the human-facing part of the harness. You can now work with Claude to design how Claude works with you — the core of the Attention Interface concept.
Reversing the harness direction
The agent harness began as an interface between the agent and the machine it runs on: you prompt, the agent issues commands, edits files and calls tools. Gradually, though, the harness is becoming an interface from the agent to the human. Claude Mods let you reverse the direction: instead of pointing from agent to machine, the harness can point from agent to human operator and become a way to manage human attention.
Mods make the human layer programmable by the human who uses Claude. Claude itself can also build mods for you: Claude Code includes a built-in skill that teaches it how to author mods, so you can request a mod in plain language and Claude will construct it.
Mods in practice
Some of Claude Code’s features are already implemented as mods. Anthropic ships six built-in mods; you can view them by running /plugin and opening Installed under Built-in. They are:
- agents-md: loads AGENTS.md as project instructions.
- diff: takes over /diff and draws its own pane.
- plugin-authoring: gives Claude the skill it uses to write mods for you.
- sec-default: guards organizationally managed content from user-installed mods.
- telemetry: sends analytics records logged by Claude Code and its built-in mods.
- you-should-know: a side agent that shows a note above the prompt when it finds something you might have missed; this one is off by default.
Most of these run in the background, which indicates that Anthropic is building some parts of Claude Code as mods — even pieces you may not notice. I personally turned on You Should Know.
Two practical examples
- You Should Know
This is a native Claude Code plugin built by Anthropic. It runs a side agent that observes the main agent while it works and flags important information you’re likely to miss — tool calls or decisions that materially affect output but are buried in the agent trace. The plugin is built in but disabled until you enable it.
A real example: I asked Claude Code to simplify noisy UI text in a personal project. The main agent trimmed copy on the Compare screen, installed the new build, and took before-and-after screenshots. Everything looked done. Then You Should Know flagged that CompareView.swift — the file the agent edited — already had uncommitted changes, and about 45 other files did too. If I had later discarded the demo edits, I would have thrown away earlier unfinished work as well. The mod suggested committing or stashing the earlier changes first. In that case, the You Should Know mod prevented accidental data loss.
- Next Steps Supervisor
This mod runs only after a turn that edited files, ran commands, or made eight or more tool calls. In the example the author shows, six different pieces of information were flagged for attention. Next Steps Supervisor then suggests a next step as a clickable button, which sends that instruction as a message back to Claude Code.
This mod is included in ModSmith, an open-source Claude Code plugin the author built. ModSmith bundles several built-in mods and a template Claude can use to build new, interoperable mods.
Attention Interfaces elsewhere
Anthropic is not the only company building an Attention Interface. Two recent products — one from OpenAI and one from Cursor — move in this direction and help clarify what’s distinctive about Claude Mods.
ChatGPT Intelligent UI (OpenAI)
On October 7, OpenAI shipped GPT-6 inside ChatGPT along with a new ChatGPT interface called Intelligent UI. Rather than answering only in text, ChatGPT can now generate interfaces while it answers — charts, maps, checklists, forms, and small tools like a bill splitter or savings calculator — a kind of generative UI produced on the fly by the model.
In OpenAI’s examples, ChatGPT replies with multiple-choice follow-up questions to narrow what you’re looking for: the model decides when it needs your judgment and then builds the interface for you to supply it. That is an Attention Interface, but the critical difference is that for Intelligent UI the model picks the interface, answer by answer, from a component library OpenAI built. At launch the only control mentioned was turning the visuals down.
Cursor: PR Routing & Approval
Cursor approaches the same problem from the other end: not a single person and answer, but a team and a stream of pull requests, increasingly authored by agents. Someone must decide which changes deserve human attention.
PR Routing & Approval does that work: it assigns reviewers based on code ownership and commit history, and it can auto-approve low-risk PRs. It weighs a risk score against a threshold you set, findings from Cursor’s Bugbot and Security reviewers, and policy files stored in the repository.
One rule stood out during research: if a PR edits an approval policy, the agent will not use the edited policy to relax review on that same PR; it reads the policy from the base branch. That prevents an agent from changing rules to get its own PR approved. Cursor’s documentation also states this feature "does not replace a full code review." Its aim is to focus human review where it matters, not to remove it.
Comparing the three approaches
All three systems shape what gets your attention and how. The key difference is who designs the Attention Interface:
- ChatGPT Intelligent UI: the model designs the interface for each answer, inside a lab-built frame. Zero setup but little control for users.
- Cursor PR Routing & Approval: the team writes policy and a fixed review workflow enforces it. Configurable rules but the interaction flow is Cursor’s.
- Claude Mods: you and the agent build the interface itself in code. A mod can hook into any point in the loop — from your prompt to the agent’s tool call to the end of a turn — and decide what to show and what actions to offer.
The author’s supervisor example illustrates this: Cursor could route a PR to a reviewer, and ChatGPT could render a verdict as a nice card, but neither would let the author insist that every turn that edits a file gets a second opinion, that the opinion lists shortcuts taken, and that each next step is one keypress away. That specific interface exists because the author prefers to allocate attention that way and Claude built it with them.
ChatGPT and Cursor give you an Attention Interface someone else designed; Claude Mods let you design your own with Claude, but you are responsible for making it useful.
Downsides of mods
Mods have costs and limitations.
-
Noise: Next Steps Supervisor triggers on most turns. Since the author installed it on October 15, 99 out of 111 of their Claude Code turns met the threshold (editing files, running commands, or 8+ tool calls). Some of those notifications are useful; others are noise. If a mod speaks up almost every turn, users begin skimming past it and the Attention Interface fails.
-
Cost: each supervisor check forks the conversation and re-reads it. Much comes from the prompt cache, but the mod’s README estimates roughly 5–6k input-equivalent tokens per check for a 50k-token session, and more when the cache has expired.
-
Trust and permissions: a mod is code that runs with your permissions. Anthropic’s documentation is clear: once loaded, a mod can read and write your files, see every prompt you send, and spend your usage. Moreover, "mods aren't sandboxed." Built-in mods also keep running when you start Claude Code with --safe-mode enabled. The author is comfortable with mods they wrote or that ship with Claude Code, but recommends reading others’ code before installing.
A practical upside is that mods are fixable. If the supervisor is noisy for a session, /supervisor off turns it off. Because it’s the author’s mod, they can change when it runs.
Where this might go next
Customizing the harness won’t be a win for every engineer: every mod you add is another piece of information needing your attention. In one session the author’s Next Steps Supervisor marked a task as "Solved" while also listing two gaps and three shortcuts. Agents are smart but imperfect, and human attention is too.
The author’s test for a mod’s usefulness is simple: did it surface something they would have missed, make a decision easier, or let them act without getting distracted by extra output? If not, it’s just window-dressing.
Today mod creation is reactive: notice friction, describe the mod you want, and Claude helps build it. The next step would be for the harness to notice friction itself. Claude Code already stores session transcripts; imagine a background process that reads them, finds repeated corrections or manual checks, suggests a mod, helps you test it, and refines it from your feedback. That would be the ideal for AI engineers: a malleable harness that suggests improvements from real-world use.
Claude Mods are a step toward that future. If the author’s bet holds, in a few years we’ll talk about startups built on Claude Code, Codex, or yet another harness platform.
A practical question to leave with readers: what friction have you noticed while using Claude Code that you could solve with a mod today?
