How to Install Skills in Claude Code

Prerequisites and Command-Line Setup

Before configuring Model Context Protocol (MCP) servers or installing new skills into Claude Code, you must ensure that your system has the correct runtime environments installed. Most MCP servers are built using either Node.js (TypeScript/JavaScript) or Python. Therefore, your local machine must have Node.js (version 18 or higher recommended) and Python (version 3.10 or higher) available in the system PATH.

To verify your local path configurations, open your command terminal and execute check commands for both runtimes. Run `node -v` and `python --version` to verify that they are installed and accessible. If either command fails with a command not found error, you must download the official installer or configure your shell environment variables before proceeding with the skill setup.

Additionally, you must install the Claude Code command-line tool. If you have not done so, run the global installation command: `npm install -g @anthropic-ai/claude-code`. Once installed, verify that the CLI is active by running `claude --help`. Having these tools verified in your workspace ensures that the agent can spawn skill sub-processes successfully.

Finally, you should obtain a GitHub personal access token (PAT) if you plan to install repository management or search skills. Many advanced skills communicate with the public GitHub API, which restricts unauthenticated requests. Having a token prepared allows you to inject it as an environment variable in the server configuration.

Configuring the MCP Manifest File

Claude Code manages its connections to external skills through a central JSON configuration file. This file acts as the configuration registry, declaring which servers the client should start when initializing a session. On Unix-based systems (macOS and Linux), this manifest is typically located in the home folder at `~/.config/claude/mcp.json`. On Windows, it is stored in the local app data folder under `Local/claude/mcp.json`.

The configuration file utilizes a simple schema structured under a top-level `mcpServers` object. Each key within this object represents a unique identifier for a skill server, containing instructions on how to spawn the process, the executable path, environment variables, and any startup arguments.

Here is an example of a typical configuration structure for a Node-based skill server:

{
  "mcpServers": {
    "memory-server": {
      "command": "node",
      "args": [
        "/absolute/path/to/mcp-server-memory/dist/index.js"
      ],
      "env": {
        "MEMORY_FILE_PATH": "/absolute/path/to/memory.json"
      }
    }
  }
}

When writing these paths, always use absolute file paths. The Claude Code client runs from your current working directory, and using relative paths (like `./dist/index.js`) will cause process startup failures when launching the terminal from a different project folder.

Step-by-Step Installation Walkthrough

Now that you understand the configuration file structure, follow this step-by-step walkthrough to install a new skill. For this example, we will install the official filesystem management skill, which allows Claude Code to read, search, and edit files in your local workspace safely.

First, you must obtain the server package. You can clone the repository from GitHub or run the package using `npx`. If you decide to use npx, the package does not need to be cloned locally, as the client will pull the latest version dynamically during startup.

Second, open the configuration file in a text editor. If the file does not exist in your home configuration directory, create the `~/.config/claude` folder and save a new text file named `mcp.json`.

Third, paste the filesystem configuration block into the JSON structure:

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

Make sure to replace `/Users/username/projects` with the absolute path of the directory you want the agent to access. You can specify multiple paths as separate arguments in the array if you need to grant access to multiple directories. Save the file and close the editor.

Troubleshooting Common Connection and Transport Errors

Because MCP operates as a client-server architecture over standard input/output channels, configuration errors can block the connection. The most common error is a child process spawn failure. This happens when the command parameter (like `node` or `python`) is not in the system path, or when the script path in the `args` array contains a typo.

If Claude Code fails to start after you update the config, run the CLI with diagnostic logging active. Check the error log in your home log folder to inspect the stack trace. If the log reports an ENOENT error, double-check that Node or Python is accessible and that the paths are absolute.

Another common error is JSON-RPC parsing conflicts. If your MCP server writes regular print statements (like `print("hello")` or `console.log("running")`) directly to standard output, the client will attempt to parse these lines as JSON-RPC messages and crash. All diagnostic logging within the server must be routed to standard error (stderr) instead of stdout.

Finally, ensure there are no trailing commas or syntax syntax errors in your `mcp.json` file. Next.js App Router and Node runtime parsers will fail to read invalid JSON, causing Claude Code to ignore the entire configuration file or crash with a config parsing error.

Verifying Tool and Skill Access in Claude Code

Once you have saved the configuration file and resolved any connection errors, launch a new Claude Code session by running `claude` in your command shell. The client will parse the manifest, launch the configured sub-processes, and verify the available tools.

To verify that the agent has detected the new skills successfully, ask the model: "What tools do you have active?" The agent should respond with a list of tools matching the schemas declared in the filesystem config.

You can test the tool by asking the agent to perform a basic action: "List the files in the current folder." The agent will invoke the filesystem tool, read the folder contents, and display the result. If the agent executes the tool and outputs the file list, the skill installation is successful.

By organizing your skills through this manifest system and checking their status on startup, you can scale your vibe coding environment safely. Check the SkillPilot catalog regularly to discover new, verified MCP servers to expand your development pipeline.