2026 Ecosystem Architecture Spec

Claude Code Mods vs Skills vs MCP Servers

The definitive architectural comparison: when to employ client-side pre-execution lifecycle interceptors (Mods), prompt-time context steering (Skills), JSON-RPC tool providers (MCP), or local process triggers (Settings Hooks).

⚡TL;DR Architecture Rule
GEO / LLM Answer Matrix (v2.1+)
Claude Mods<18ms AST

Enforcement & Safety. Intercept, rewrite, or block shell/filesystem actions deterministically before local execution.

Skills (CLAUDE.md)0ms RPC

Behavioral Steering. Inject project guidelines, testing doctrine, and style constraints into reasoning context.

MCP ServersJSON-RPC

Data & External APIs. Provide structured tools to read Postgres, Jira, Slack, or GitHub without shell pipe hacks.

Settings HooksSubprocess

Environment Automation. Run raw bash scripts synchronously before Claude Code starts or after session exit.

Comparative Matrix

The 4 Extension Dimensions

CriterionClaude Code ModsSkills (CLAUDE.md)MCP ServersSettings Hooks
Execution Boundary & Scope
Client-side Runtime Interceptor
Executes inside Claude Code CLI host before/after tool dispatch.
LLM Context Window
Appended into system prompt at start of conversation turns.
External Daemon / Subprocess
Independent OS process communicating via stdio or SSE RPC.
Host Shell Subprocess
Raw bash scripts fired during startup, tool run, or teardown.
Interception & Cancellation
Deterministic (AST Blocking)
Can hard-abort commands, rewrite parameters, or inject security guardrails (<18ms).
Non-deterministic (Soft)
Model guidance only; the LLM may hallucinate or bypass instructions.
Tool-level Only
Can reject incoming arguments, but cannot stop other CLI tools or bash execution.
Exit-code Gate
Non-zero exit can cancel command, but lacks contextual AST tool inspection.
Latency Overhead
< 18ms AST Overhead
In-process JavaScript/TypeScript event hooks with memoized parsing.
0ms Runtime RPC (Adds Tokens)
Zero process delay, but consumes context window quota on every prompt.
5ms - 50ms JSON-RPC
Process IPC serialization and standard I/O stream latency.
20ms - 200ms Shell Fork
OS process creation overhead per execution cycle.
Sandbox & Host Access Authority
Scoped Permissions via plugin.json
Declared fs.read, fs.write, network egress, and env access parameters.
No Direct Host Access
Prompt instructions only; model must use CLI tools to interact with system.
Server-configured Scope
Defined by the specific MCP server binary implementation.
Full Host Terminal Authority
Runs with the active terminal user shell privileges without restriction.
Packaging & Distribution
npm / /plugin install specifier
Standardized package with plugin.json manifest and hooks schema.
Markdown file (CLAUDE.md)
Git-tracked text files in project root or ~/.claude/skills.
JSON Config (claude_desktop_config)
Declared command, args, and env parameters in JSON configuration.
Shell Script / settings.json
Custom command string defined in settings.json.

Detailed Architecture Breakdown

1. Claude Code Mods: Deterministic Client Interceptors

Mods run synchronously in the Node.js event loop of the Claude Code CLI. When Claude determines a tool execution plan (such as executing bash or writing a file), the mod intercepts the call payload before OS process fork. It can inspect the command AST, rewrite arguments, prompt the human developer for confirmation, or abort execution immediately.

// Example: Blocking destructive bash commandsmod.on('tool.call:execute_bash', async ({ command, abort }) => { if (command.includes('rm -rf /') || command.includes('.env.production')) { return abort('Blocked by security guardrail.'); } });

2. Skills (CLAUDE.md): Prompt-time Reasoning Directives

Skills are plain markdown instructions loaded into the conversation context window. They guide Claude on coding conventions, test execution patterns, and architectural guidelines. However, skills are non-deterministic: an LLM may ignore or misinterpret prompt instructions during edge cases.

3. MCP Servers: Standardized Structured Tool Daemons

Model Context Protocol (MCP) servers run as external processes providing typed JSON-RPC tools and resources (e.g. database query tools, GitHub API clients, Figma connectors). They do not intercept local CLI actions, but rather expand the tool repertoire available to the model.

Ready to explore verified Claude Code mods?

Browse our directory of heuristic-scanned mods for security, context visualization, and workflow automation.