Skills, MCP, and extending an agent

Standing instructions tell an agent how to behave. Sometimes you want to give it more: a procedure to follow for a particular kind of task, or a connection to a tool or data source it does not have. Three mechanisms cover most of that — skills, MCP, and commands — and they share one design goal: add capability without permanently bloating the agent’s context.

Skills: packaged know-how, loaded on demand

A skill is a folder with a SKILL.md file — a name, a description of when to use it, and the instructions (plus any scripts it needs). The useful part is progressive disclosure: the agent sees only each skill’s name and description until a task matches one, and loads the full content only then. So you can have a hundred skills installed and pay the context cost of just the one the job needs.

For example, a “release-notes” skill might describe itself as “use when cutting a release” and hold the exact steps plus the script that builds the changelog. The agent ignores it on every other task and pulls it in on the one where it applies. A minimal one:

---
name: release-notes
description: Use when cutting a release — builds the changelog and tags the version.
---

1. Run `scripts/changelog.sh` to collect merged PRs since the last tag.
2. Draft the notes, grouped by type, and open a PR with the new tag.

In Claude Code , skills live in ~/.claude/skills/<name>/ (personal) or .claude/skills/ (project, shared with the team). Anthropic introduced skills in late 2025 and published the format as an open standard, and it spread fast: OpenAI’s Codex and Cursor read the same SKILL.md format, so a skill is becoming portable across agents — the way MCP did before it.

MCP: connect the agent to your tools and data

Where a skill packages instructions, the Model Context Protocol (MCP) packages capabilities. An MCP server exposes tools and data — your issue tracker, a database, an internal API — and any MCP-aware agent can call them. It is the standard answer to “the agent needs to reach a system it does not already know about.”

MCP matters because it is genuinely cross-vendor. Anthropic introduced it in late 2024; OpenAI, Google, and Microsoft all adopted it through 2025; and it is now governed as an open standard under the Linux Foundation. So an MCP server you write is not tied to one agent — it works with whichever ones speak the protocol. In Claude Code you add one with claude mcp add or a project .mcp.json. Many of the connectors an agent reaches — a browser, a drive, an issue tracker — are MCP servers underneath.

Commands, subagents, and hooks

Three smaller mechanisms (Claude Code’s names; other tools have close equivalents) round this out:

• Custom commands — a prompt you trigger yourself with /name. In Claude Code these have merged into skills: a skill marked manual-only is a slash command. Use one for a routine you want to invoke deliberately rather than leave to the agent’s judgment.
• Subagents — a specialized agent with its own context, system prompt, and restricted tools, that the main agent hands a focused sub-task. This is multi-agent orchestration inside a single tool: a code-reviewer subagent reviews with fresh eyes; a search subagent reads widely without filling the main agent’s context.
• Hooks — shell commands that fire deterministically at lifecycle points (before a tool runs, after a file is edited). Where instructions and skills ask the agent to do something, a hook makes it happen — run the formatter after every edit, or block a command you never want run. That determinism is exactly why a hook, not a sentence in an instructions file, is where you put a guardrail you cannot afford the agent to skip.

Choosing among them

• Behavior that applies everywhere → standing instructions .
• A procedure for a specific kind of task → a skill.
• Access to an external tool or data source → an MCP server.
• A guarantee that must always hold → a hook.

Each of these adds surface area, though, and an agent with fifty skills, ten MCP servers, and a crowded instructions file is harder to predict, not easier. Add one when a real need appears — the same restraint as designing tools : a small, reliable set beats a large, possible one.

Where to go next

• The standing-instructions half: Give an agent standing instructions .
• The pattern subagents implement: Multi-agent orchestration .