How to Use AI Agent Skills and Plugins in Claude Code and Codex: A Practical Guide
Skills are reusable instruction files; plugins bundle skills, agents, and MCPs. Learn how to install and use both in Claude Code, Codex, and other harnesses.
What Skills and Plugins Actually Are (and Why It Matters)
If you’ve spent any time with Claude Code or OpenAI Codex, you’ve probably noticed that raw instruction-following only gets you so far. The agent can reason, plan, and write code — but connecting it to external APIs, reusing consistent behaviors across projects, or bundling complex toolchains requires something more structured.
That’s where AI agent skills and plugins come in. Skills are reusable instruction files that tell an agent how to perform a specific task or follow a specific pattern. Plugins bundle those skills together with agents and MCP (Model Context Protocol) servers into portable, shareable packages. Understanding how to install and use both in Claude Code, Codex, and other harnesses will meaningfully change what you can build and how fast you can build it.
This guide walks through the practical mechanics — what skills and plugins are, how they differ, and how to get them working in the two most popular agentic coding environments today.
Skills vs. Plugins: A Clear Distinction
Before jumping into configuration, it helps to know exactly what you’re working with.
What a Skill Is
- ✕a coding agent
- ✕no-code
- ✕vibe coding
- ✕a faster Cursor
The one that tells the coding agents what to build.
A skill is a reusable instruction file — typically a markdown file — that captures a specific capability or behavioral pattern. Think of it as a standing operating procedure for your agent. Instead of re-explaining “how to write a unit test” or “how to handle database migrations” every time you start a session, a skill file encodes that logic once and makes it available on demand.
Skills can be:
- Task-specific (e.g., “how to scaffold a new Express route”)
- Domain-specific (e.g., “conventions for this codebase’s error handling”)
- Tool-specific (e.g., “how to interact with a particular API”)
Skills don’t execute code themselves. They provide structured context that shapes how the agent reasons and responds.
What a Plugin Is
A plugin is a higher-level bundle. It typically packages:
- One or more skills
- Agent configurations
- MCP server definitions
- Any associated tools or integrations
Plugins are designed to be installed and reused across projects without manual reassembly. When you install a plugin in Claude Code or Codex, you’re importing a complete capability set — not just a single instruction file.
The difference matters practically. If you want an agent that follows your team’s documentation style, a skill handles that. If you want an agent that follows your docs style and connects to your internal API and knows how to deploy to your staging environment, a plugin bundles all of that together.
How Skills Work in Claude Code
Claude Code (Anthropic’s agentic coding tool) has a well-defined system for skills, even if Anthropic doesn’t always use that word explicitly.
The CLAUDE.md File
The foundational skill mechanism in Claude Code is the CLAUDE.md file. When Claude Code launches in a project directory, it reads any CLAUDE.md file it finds and treats those instructions as persistent context throughout the session.
You can place CLAUDE.md files at multiple levels:
- Global:
~/.claude/CLAUDE.md— applies across all projects - Project root:
./CLAUDE.md— applies to all work in that repository - Subdirectory:
./src/CLAUDE.md— applies only when working in that subdirectory
Claude Code merges these files, with more specific (deeper) files taking precedence.
Writing an Effective Skill File
A good CLAUDE.md skill file covers:
- Project-specific conventions (naming patterns, file organization)
- Common commands the agent should know about
- Preferred libraries or approaches
- Things the agent should never do (e.g., “never modify migration files directly”)
- How to interact with specific tools or scripts
Here’s a practical example structure:
# Project Conventions
## Tech Stack
- Node.js 20, TypeScript, Prisma, Postgres
- Frontend: Next.js 14 with App Router
## Code Style
- All functions must have JSDoc comments
- Use `zod` for input validation at API boundaries
- Prefer named exports over default exports
## Common Commands
- `npm run dev` — start dev server
- `npm run db:push` — push schema changes to local DB
- `npx prisma studio` — open DB GUI
## What Not to Do
- Never edit files in `/generated` — they are auto-generated
- Never commit `.env` filesThis becomes a reusable skill when you share it across team members or across projects that follow similar patterns.
Importing External Skills
Claude Code supports importing skills from external sources through the /import command or by referencing files in the .claude/ directory. You can maintain a library of skill files in a shared repository and pull them into projects as needed.
For example, a team might maintain:
shared-skills/
testing-conventions.md
api-patterns.md
deployment-checklist.mdRemy doesn't build the plumbing. It inherits it.
Other agents wire up auth, databases, models, and integrations from scratch every time you ask them to build something.
Remy ships with all of it from MindStudio — so every cycle goes into the app you actually want.
Each project imports the relevant files into its local .claude/ directory.
How Plugins Work in Claude Code
Plugins in Claude Code extend capabilities beyond what instruction files alone can provide. The primary plugin mechanism is MCP (Model Context Protocol) servers.
What MCP Servers Add
MCP is an open protocol that lets Claude connect to external tools, data sources, and services. When you configure an MCP server as a plugin, Claude Code can:
- Query databases and APIs
- Read from file systems outside the project
- Trigger external workflows
- Use specialized tools that would otherwise require custom code
Installing an MCP Plugin in Claude Code
You configure MCP servers in Claude Code through the settings interface or directly in the configuration file at ~/.claude/settings.json (or .claude/settings.json for project-level config).
A typical MCP plugin configuration looks like this:
{
"mcpServers": {
"my-tool": {
"command": "npx",
"args": ["-y", "@my-org/my-mcp-server"],
"env": {
"API_KEY": "your-key-here"
}
}
}
}Once configured, Claude Code automatically starts the MCP server and makes its tools available during your session. You can verify what tools are loaded by running /mcp in the Claude Code interface.
Plugin Permissions
Claude Code uses a permission system for MCP plugins. Some tool calls require explicit approval before Claude can run them, particularly those that:
- Write to the file system
- Make external network requests
- Execute system commands
You can configure trust levels per server in settings, or set a server to “auto-approve” for tools you use frequently and trust.
How Skills and Plugins Work in OpenAI Codex
OpenAI Codex (available as a CLI tool and integrated in various environments) has its own approach to skills and extensibility.
Codex and Instruction Files
Similar to Claude Code, Codex CLI reads instruction context from markdown files. The AGENTS.md file serves a parallel role to CLAUDE.md — it provides persistent context that shapes how the agent behaves across a session.
Codex searches for AGENTS.md at the same directory hierarchy levels: user home, git repository root, and current working directory. When multiple files exist, it concatenates them with more specific files given higher priority.
Writing Skills for Codex
The structure of a good Codex skill file mirrors what works in Claude Code — project conventions, command references, and behavioral guardrails. The main difference is that Codex is designed to operate more autonomously with longer task chains, so skill files often include more explicit checkpointing instructions:
# Project Skills
## After Each Major Change
1. Run `npm test` and confirm passing
2. Check for TypeScript errors with `npm run type-check`
3. Commit with a descriptive message
## API Integration Pattern
- All API calls go through `/lib/api-client.ts`
- Never make fetch calls directly from components
- Use the `ApiError` class for error handlingPlugins in Codex
Codex supports tool plugins through function definitions that can be passed at the API level. When using Codex programmatically, you define tools as JSON schema objects, and the model decides when to call them based on the task at hand.
Other agents start typing. Remy starts asking.
Scoping, trade-offs, edge cases — the real work. Before a line of code.
For the Codex CLI specifically, plugin support is handled through the configuration file, where you can define allowed shell commands and tool integrations.
Installing and Managing Skills Across Projects
One of the more useful things you can do is build a personal or team skill library and deploy it consistently.
Building a Skill Library
Start by identifying the patterns that show up repeatedly:
- How do you structure tests?
- What’s your preferred error handling pattern?
- Which commands does every project need?
- What should never happen (the “don’t do this” list)?
Store these in a version-controlled repository. Each skill is a standalone markdown file focused on one area.
Deploying Skills to Projects
The simplest approach is a setup script that symlinks or copies skill files into the correct locations:
#!/bin/bash
SKILLS_REPO="$HOME/team-skills"
PROJECT_DIR="$(pwd)"
mkdir -p "$PROJECT_DIR/.claude"
cp "$SKILLS_REPO/testing.md" "$PROJECT_DIR/.claude/"
cp "$SKILLS_REPO/api-patterns.md" "$PROJECT_DIR/.claude/"
cat "$SKILLS_REPO/base.md" >> "$PROJECT_DIR/CLAUDE.md"More sophisticated setups use npm packages or internal package registries to distribute skills as versioned artifacts — especially useful when your team has dozens of projects that need to stay in sync.
Keeping Skills Updated
Treat skills like code. Review them in PRs. Update them when patterns change. If a skill causes the agent to consistently produce wrong output, that’s a bug worth fixing.
Where MindStudio Fits
If you’re building agents that need to do things — not just write code, but send emails, generate images, query external APIs, or trigger workflows — the MindStudio Agent Skills Plugin is worth understanding.
The @mindstudio-ai/agent SDK
MindStudio publishes an npm SDK (@mindstudio-ai/agent) that exposes 120+ typed capabilities as simple method calls. You install it once, and your agent — whether it’s Claude Code, LangChain, CrewAI, or a custom harness — can call methods like:
await agent.sendEmail({ to: "user@example.com", subject: "Done", body: "Task complete" });
await agent.generateImage({ prompt: "product mockup, clean background" });
await agent.searchGoogle({ query: "latest framework releases" });
await agent.runWorkflow({ id: "my-workflow-id", inputs: { ... } });The SDK handles rate limiting, retries, and auth — which means the agent’s reasoning loop doesn’t have to care about infrastructure. It just calls the method.
This is genuinely useful in an agentic coding context. If you’re using Claude Code to build an automated pipeline — say, one that generates documentation and emails a summary to stakeholders — you can drop the MindStudio plugin into your MCP configuration and give Claude Code access to those capabilities without writing custom API integration code.
Using MindStudio as an MCP Server
MindStudio also supports exposing agents as MCP servers, which means you can build a workflow in MindStudio’s no-code environment and then call it as a tool from Claude Code or Codex.
This is particularly useful when you have non-technical teammates who need to maintain part of a workflow. They manage their piece in MindStudio’s visual builder; you call it as a plugin from your coding agent. The two environments stay connected without either side having to change their tools.
You can try MindStudio free at mindstudio.ai.
Common Mistakes When Working with Skills and Plugins
Even when you understand the concepts, a few patterns reliably cause problems.
Skill Files That Are Too Long
If a skill file tries to cover everything, the agent will weight important instructions the same as minor preferences. Keep each skill file focused. If a file is longer than 400 lines, split it.
Conflicting Instructions Across Files
When multiple skill files are merged, conflicting instructions create unpredictable behavior. The agent will try to reconcile them — usually badly. Audit your skill files regularly for contradictions.
MCP Servers That Fail Silently
If an MCP server fails to start, Claude Code will often continue without it — you just won’t have access to those tools. Always verify your MCP servers are running after configuration changes using /mcp in Claude Code’s interface.
Trusting Too Much
Setting an MCP plugin to auto-approve all actions is convenient but risky. Be deliberate about which tool categories get auto-approval. File writes and external API calls should generally stay in the explicit-approval tier unless you have strong confidence in how the agent uses them.
Not Versioning Skills
Skills that live only on one developer’s machine are a liability. When that person leaves or changes machines, the institutional knowledge disappears. Store skills in version control from day one.
Frequently Asked Questions
What is the difference between a skill and an MCP server?
A skill is a passive instruction file — it gives the agent context and behavioral guidance but doesn’t add new tools. An MCP server is active — it exposes specific tools the agent can call to take real actions, like querying a database or triggering an API. Skills shape how the agent thinks; MCP servers expand what it can do.
Can I use the same skill files in both Claude Code and Codex?
Largely yes. Both Claude Code (CLAUDE.md) and Codex (AGENTS.md) read markdown instruction files with similar semantics. You may need minor adjustments for tool-specific instructions, but the core behavioral guidance — code conventions, patterns, guardrails — transfers cleanly between environments.
How do I know which plugins are currently active in Claude Code?
Run /mcp in the Claude Code interface. This displays all configured MCP servers and their current status (running, stopped, or errored). If a server isn’t listed or shows as stopped, check your configuration file and verify the server command is installed and accessible.
Are skills and plugins the same as system prompts?
They overlap but aren’t identical. A system prompt is injected at the start of a model conversation and shapes the entire session. Skills (like CLAUDE.md) are a form of system prompt — they get prepended to context. But skills are more structured: they’re files you maintain separately, can version control, and can compose. Plugins go further by adding tool capabilities, not just instructions.
Can multiple people on a team share the same skills?
Yes, and this is one of the best uses of skills. Store your skill files in a shared repository. Team members pull them into their projects via a setup script, symlinks, or a package manager. When the team updates a skill, everyone benefits immediately — or at their next pull, depending on how you manage distribution.
What happens if a skill file has contradictory instructions?
The agent will attempt to reconcile them but may produce inconsistent results. In Claude Code, files closer to the current working directory take priority over parent directories, and parent directories take priority over the global config. Within a single file, instructions later in the document generally override earlier ones. The safest approach is to avoid contradictions by keeping skills narrowly scoped.
Key Takeaways
- Skills are reusable instruction files (like
CLAUDE.mdorAGENTS.md) that shape agent behavior without adding new tool capabilities. - Plugins bundle skills, agents, and MCP servers into installable packages that extend what an agent can actually do.
- Claude Code and Codex both support hierarchical instruction files — global, project-level, and directory-level — that merge to form the agent’s operating context.
- MCP is the primary plugin mechanism in Claude Code — configure MCP servers in your settings file to give the agent access to external tools and APIs.
- Keep skills focused and versioned — broad, unversioned skill files lead to conflicting instructions and institutional knowledge loss.
- Tools like MindStudio’s Agent Skills Plugin let you connect coding agents to 120+ external capabilities without writing custom integration code, bridging the gap between agent reasoning and real-world actions.
If you’re building agents that need to go beyond reasoning and actually trigger workflows, send communications, or connect to business tools, MindStudio is worth exploring as both a workflow layer and an MCP-compatible plugin source.
