Giving Your AI Hands: Implementing Official Plugins for Agentic Development

anthropics/claude-plugins-official

The Model Context Protocol (MCP) and the plugins found in the anthropics/claude-plugins-official repo are absolute game-changers for local development and agentic workflows.

Think of standard LLMs as a brilliant brain in a sensory deprivation tank. They know everything but can't "touch" your code or your tools.

MCP (Model Context Protocol) changes that. It provides a universal, open standard for connecting AI models to data sources and tools. By using these official plugins, you give your AI assistant "hands" to

Read/Write files directly in your workspace.

Query your database to understand schema or debug data issues.

Search the web or documentation without you copy-pasting links.

Execute terminal commands (with your permission) to run tests or builds.

The easiest way to use these is via Claude Code (the CLI tool) or the Claude Desktop app.

First, ensure you have Node.js installed, then run

npm install -g @anthropic-ai/claude-code

To use a plugin from the official directory, you add it to your configuration. For example, if you want to give the AI access to your local filesystem

Open your Claude Desktop config (usually at ~/Library/Application Support/Claude/claude_desktop_config.json on macOS).

Add the server details.

Here is what your configuration file looks like when you want to enable a specific tool (like the filesystem tool)

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "/Users/yourname/projects"
      ]
    }
  }
}

Once configured, you don't need to write "code" to call the plugin. You simply talk to the CLI

You
"Find all instances of deprecatedMethod() in this folder and replace them with newMethod()."

Claude
Uses the filesystem plugin to search, read, and write the changes automatically.

As an engineer, you might want to build your own "skill" or plugin. MCP uses a simple JSON-RPC 2.0 transport. Here is a simplified conceptual example of how a "Weather Skill" MCP server would be structured in TypeScript

import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";

// 1. Initialize the server
const server = new Server({
  name: "weather-checker",
  version: "1.0.0"
}, {
  capabilities: { tools: {} }
});

// 2. Define a tool (a "Skill")
server.setRequestHandler(ListToolsRequestSchema, async () => ({
  tools: [{
    name: "get_weather",
    description: "Get current weather for a city",
    inputSchema: {
      type: "object",
      properties: {
        city: { type: "string" }
      }
    }
  }]
}));

// 3. Connect via Standard Input/Output
const transport = new StdioServerTransport();
await server.connect(transport);

This setup effectively turns your LLM into a pair programmer with full context of your environment.