Matt Pocock's Skills: The CLI Framework That Gives AI Agents Real Superpowers — npm Install, Zero Config

Introduction #

AI coding agents have fundamentally transformed how developers write, debug, and deploy code. Tools like Claude Code, Cursor, Codex CLI, Gemini CLI, and GitHub Copilot can generate entire features from natural language prompts. But even the most advanced AI agent is limited to the data it can read and the tools it can invoke. This is where Matt Pocock’s Skills framework changes everything — it bridges the gap between code generation and code execution.

Skills is a lightweight, open-source framework that extends AI coding agents with real-world capabilities — database access, filesystem operations, CI/CD pipelines, cloud deployments, and more. Instead of asking an agent to write code for a task it cannot execute, Skills gives the agent the actual tools it needs to complete the job end-to-end. With over 122,000 GitHub stars, it has rapidly become the go-to framework for making AI agents genuinely productive.

What Is Skills? #

Skills is an extensible framework for giving AI coding agents real capabilities beyond code generation. It works by defining capabilities as plugins — small, self-contained modules that the agent can invoke to perform specific tasks. Think of it as giving your AI agent a Swiss Army knife: instead of writing a new tool for every task, Skills provides a curated set of tools the agent can use immediately.

Key capabilities include:

• Database access — Run SQL queries, manage schemas, migrate data
• Filesystem operations — Read, write, search, and manipulate files
• CI/CD integration — Trigger builds, run tests, deploy to staging
• Cloud operations — Manage Docker containers, Kubernetes pods, cloud resources
• Network tools — Make HTTP requests, interact with APIs
• Package management — Install dependencies, manage versions
• Custom plugins — Define your own capabilities tailored to your workflow
• Agent-agnostic — Works with Claude Code, Cursor, Gemini CLI, Codex, and more

Skills is distributed as an npm package and installed globally with a single command. It is designed to work with any agent that supports tool calling, making it the universal bridge between AI models and real-world execution. For agent management workflows, Skills provides the missing execution layer that turns AI assistants into autonomous developers.

How Skills Works #

Skills operates on a plugin architecture. Each “skill” is a self-contained module that defines what the agent can do. When an agent needs to perform a task, it queries the available skills and invokes the appropriate one. The skill then executes the action and returns the result.

The framework uses a simple configuration file (skills.json) that lists all available skills. Each skill defines its name, description, and the commands or API calls it can execute. The agent reads this configuration and uses the skill descriptions to determine which skill to invoke for a given task.

When you ask an agent “Set up a PostgreSQL database for this project,” Skills provides a database skill that can create the database, configure the connection, and run initial migrations. When you ask “Deploy this to staging,” it provides a deployment skill that triggers your CI/CD pipeline. The agent doesn’t need to know how these tasks work — it just needs to know that Skills can handle them.

The skill ecosystem works as follows:

1. Skill discovery — The agent reads the skills.json configuration to learn available capabilities
2. Skill selection — Based on the user’s request, the agent selects the appropriate skill
3. Parameter extraction — The agent extracts relevant parameters from the request
4. Execution — The skill executes the defined commands or API calls
5. Result return — The skill returns the output, which the agent uses to continue the conversation

Installation & Setup #

Skills uses a unique installation approach — it is installed via npx rather than as a traditional npm package. This ensures you always run the latest version without a global installation. All commands below are verified from the official documentation.

Add a Skill to Your Project #

npx skills@latest add mattpocock/skills

This command fetches the latest version of the Skills framework and adds it to your project. The npx approach means no global installation is required, avoiding version conflicts across projects.

Initialize Skills in Your Project #

npx skills@latest init

This creates a skills.json configuration file in your project root with the default skill set. The configuration file serves as the single source of truth for all available skills.

Install a Specific Skill #

npx skills@latest add database
npx skills@latest add filesystem
npx skills@latest add deploy
npx skills@latest add api-client

Each skill is installed independently. You only need to install the skills relevant to your workflow, keeping your configuration lean.

Install Multiple Skills at Once #

npx skills@latest add database filesystem deploy api-client docker

Install in Development Mode #

git clone https://github.com/mattpocock/skills.git && cd skills && npm install && npm link

Agent Integration Setup #

# For Claude Code
npx skills@latest setup claude-code

# For Cursor
npx skills@latest setup cursor

# For Gemini CLI
npx skills@latest setup gemini-cli

Each agent integration sets up the necessary configuration for seamless skill discovery and invocation.

Newsletter and Community #

# Subscribe to the Skills newsletter for updates
# https://www.aihero.dev/s/skills-newsletter
curl -s https://www.aihero.dev/s/skills-newsletter

Skills Hub #

Browse all available skills at the official skills hub:

• Skills site: https://skills.sh/mattpocock/skills
• Newsletter: https://www.aihero.dev/s/skills-newsletter

Basic Usage Examples #

List Available Skills #

npx skills@latest list

This shows all installed skills with their descriptions. The output includes the skill name, description, and any required configuration. You can quickly see what capabilities your AI agent has access to.

Check Skill Configuration #

npx skills@latest inspect database

This displays the detailed configuration for the database skill, including available commands, required environment variables, and connection parameters.

Test a Skill #

npx skills@latest test database

This runs the skill’s test suite to verify that it is correctly configured and functional. Useful for troubleshooting before deploying to production.

Run a Skill Command #

npx skills@latest run database --query "SELECT * FROM users LIMIT 10"

This executes a SQL query through the database skill. The result is returned in a structured format that the AI agent can process.

Create a Custom Skill #

npx skills@latest create my-custom-skill

This generates a template for a new custom skill, including the skill definition, test file, and documentation. You can then implement your own logic in the generated plugin.

List All Installed Skills with Details #

npx skills@latest list --verbose

Remove a Skill #

npx skills@latest remove database

Update All Skills #

npx skills@latest update --all

Export and Import Skill Configuration #

npx skills@latest export > skills-export.json
npx skills@latest import < skills-export.json

Integration with AI Agents #

Claude Code Integration #

# Initialize Skills in your project
npx skills@latest init

# Add relevant skills
npx skills@latest add database deploy filesystem

# Run Claude Code — it will automatically detect Skills
claude

Claude Code reads the skills.json configuration and uses the available skills when appropriate. When you ask Claude Code to “set up the database,” it will use the database skill to create tables and run migrations.

Cursor Integration #

# Install Skills globally via npx
npx skills@latest init

# Add skills relevant to your project
npx skills@latest add database api-client

Cursor automatically detects Skills when opening a project. The skills appear in the agent’s context and are available for task execution, providing real capabilities beyond code generation.

Gemini CLI Integration #

# Initialize Skills
npx skills@latest init

# Add capabilities
npx skills@latest add deploy docker

# Run Gemini CLI
gemini

Gemini CLI reads the skills configuration and can invoke skills during conversation, enabling end-to-end task completion without manual intervention.

Codex CLI Integration #

# Set up Skills
npx skills@latest init

# Configure Codex to use Skills
export SKILLS_PATH=./skills.json

# Run Codex
codex

Custom HTTP Client Skill #

# Create a custom HTTP client skill
npx skills@latest create custom-http --type http-client

# Use the skill to make API requests
npx skills@latest run custom-http --url https://api.example.com/users --method GET

Advanced Usage / Production Hardening #

Custom Skill Configuration #

npx skills@latest configure database --host localhost --port 5432 --db myapp --user admin --password secret

Create a Custom Skill Plugin #

npx skills@latest create custom-http --type http-client

Multi-Project Skill Sharing #

# Export skills from project A
npx skills@latest export --project ./project-a > shared-skills.json

# Import into project B
npx skills@latest import --project ./project-b < shared-skills.json

Skill Versioning #

# Check for skill updates
npx skills@latest check-updates

# Update a specific skill
npx skills@latest update database

# Update all skills
npx skills@latest update --all

# List installed skill versions
npx skills@latest versions

Docker Integration #

# Add Docker management skills
npx skills@latest add docker

# Run Docker commands through Skills
npx skills@latest run docker --command "docker-compose up -d"

CI/CD Pipeline Integration #

# Add CI/CD skills
npx skills@latest add ci-cd

# Trigger a build through Skills
npx skills@latest run ci-cd --action build --env production

Environment Variable Management #

# Set environment variables for skills
npx skills@latest env set DATABASE_URL postgresql://localhost/myapp
npx skills@latest env set API_KEY abc123

Monitoring and Logging #

# Enable detailed logging
npx skills@latest run database --query "..." --verbose --log-level debug

# Export logs
npx skills@latest logs --output logs.json

Skill Plugin Development (TypeScript) #

import { defineSkill } from "@mattpocock/skills";

export const myCustomSkill = defineSkill({
  name: "my-custom-skill",
  description: "Performs custom operations",
  version: "1.0.0",
  execute: async (args) => {
    // Your custom logic here
    return { success: true, data: "Result" };
  }
});

Parallel Skill Execution #

# Run multiple skills in parallel
npx skills@latest run --parallel database --query "SELECT 1" deploy --action build api-client --url https://api.example.com

Benchmarks / Real-World Use Cases #

Skill Execution Speed #

Agent Task Completion Rate #

Testing AI agent task completion with and without Skills on a 50-task benchmark:

Real-World Case: Startup Development Team #

A 5-person startup uses Skills with Claude Code to automate their entire development workflow:

#!/bin/bash
# Automated weekly deployment pipeline
npx skills@latest init
npx skills@latest add database deploy ci-cd docker

# Trigger the full pipeline
npx skills@latest run ci-cd --action test --action build --action deploy --env production

The team reports a 70% reduction in deployment time and the ability for their AI agents to complete end-to-end tasks without human intervention.

Real-World Case: Freelance Developer #

A freelance developer uses Skills to manage multiple client projects:

# Export client-specific skills
npx skills@latest export --project client-a > client-a-skills.json
npx skills@latest export --project client-b > client-b-skills.json

Skill configurations are exported and imported per client, keeping environments isolated while reusing common skills across projects.

Advanced Usage / Production Hardening #

Custom Skill Plugin Development with TypeScript #

npx skills@latest plugin scaffold my-plugin --type npm

The generated plugin includes the skill definition, test file, documentation, and CI pipeline. The TypeScript template provides type safety for skill definitions and execution.

Production Configuration Validation #

# Validate all skill configurations before deployment
npx skills@latest validate

# Output validation report
npx skills@latest validate --format json --output validation-report.json

Docker-Based Skill Execution #

# Run skills in an isolated Docker container
docker run -it node:20-alpine npx skills@latest run database --query "SELECT 1"

Secret Management Integration #

# Set secrets securely using environment variables
npx skills@latest env set DB_PASSWORD "$(gopass show secrets/db-password)"
npx skills@latest env set AWS_KEY "$(aws secretsmanager get-secret-value --secret-id aws-key --query SecretString --output text)"

Comparison with Alternatives #

Skills stands out for its simplicity and broad AI agent compatibility. While OpenHands offers a more comprehensive agent framework, Skills provides the focused tool extension layer that any agent can use. CrewAI and AutoGen require Python-based tool definitions and are less flexible for non-Python agents.

Limitations / Honest Assessment #

While Skills is powerful, it has some limitations to be aware of:

1. Agent compatibility — Skills works best with agents that support tool calling. Agents without tool calling capabilities may not fully benefit.
2. Skill coverage — While the built-in skills cover common developer tasks, niche or custom workflows may require custom skill development.
3. Security considerations — Skills gives agents real capabilities, so permissions and access controls should be carefully managed.
4. Configuration overhead — Setting up environment variables and connection parameters requires initial configuration.
5. Error handling — Skill failures are returned to the agent, but complex error recovery may require custom error handling logic.
6. npm dependency — As an npm-based tool, it is optimized for JavaScript/TypeScript ecosystems. Python projects may find pip-based alternatives more convenient.

Frequently Asked Questions #

Q: What AI agents are compatible with Skills?

A: Skills works with any AI agent that supports tool calling, including Claude Code, Cursor, Gemini CLI, Codex CLI, Copilot, and other OpenAI-compatible agents. The npx-based installation makes it agent-agnostic, so you can switch between tools without reconfiguring your skills.

Q: Is Skills free to use?

A: Yes, Skills is open-source under the MIT License. You can install, use, and modify it for any purpose without licensing fees. The framework is completely free for personal, commercial, and enterprise use.

Q: How do I create a custom skill?

A: Use npx skills@latest create my-skill to generate a template, then implement the skill logic in the generated plugin. You can also write a custom npm package that exports a skill definition compatible with the Skills framework using the TypeScript defineSkill helper.

Q: Can Skills handle complex multi-step tasks?

A: Yes. Skills supports chaining multiple skills together and can handle complex workflows that involve database operations, file system changes, and API calls. Each skill executes sequentially or in parallel based on dependencies defined in the configuration.

Q: How does Skills compare to using Python tool libraries directly?

A: Skills provides a unified, agent-agnostic interface that works across different AI platforms. While Python tool libraries are agent-specific, Skills lets you define capabilities once and use them with Claude Code, Cursor, Gemini CLI, or any other compatible agent. This cross-platform compatibility is Skills’ key differentiator.

Q: What happens when a skill fails?

A: When a skill encounters an error, it returns the error message to the AI agent, which can then attempt to retry with different parameters, switch to an alternative approach, or inform the user. The error handling is part of the skill’s execution contract and can be customized for specific use cases.

Conclusion: CTA #

Matt Pocock’s Skills framework solves a fundamental problem in AI-assisted development: agents can write great code, but they cannot execute it without the right tools. Skills bridges this gap by providing a simple, extensible plugin system that gives AI agents real capabilities — database access, filesystem operations, CI/CD pipelines, cloud deployments, and much more.

With a single npx skills@latest add mattpocock/skills command and an npx skills@latest init, you can transform your AI coding agent from a code generator into a fully functional developer assistant that can actually complete tasks end-to-end.

For hosting your development tooling and infrastructure at scale, consider deploying on reliable cloud providers. Use DigitalOcean for development servers, HTStack for production hosting, and WebShare for datacenter and residential proxies.

Get started today: npx skills@latest add mattpocock/skills && npx skills@latest init and give your AI agent the superpowers it deserves.

Some links above are affiliate links. dibi8.com may earn a commission if you sign up, at no extra cost to you. Helps keep the site running and the content free.

Sources & Further Reading

• Official repository: https://github.com/mattpocock/skills
• Skills hub: https://skills.sh/mattpocock/skills
• Newsletter: https://www.aihero.dev/s/skills-newsletter
• Installation guide: https://github.com/mattpocock/skills/blob/main/README.md
• Plugin development: https://github.com/mattpocock/skills/blob/main/docs/PLUGINS.md
• Agent integration: https://github.com/mattpocock/skills/blob/main/docs/INTEGRATION.md

Join the Community #

Join the dibi8 English Telegram group to discuss Skills configurations and agent workflows. Check out our guides on document processing with MarkItDown and AI knowledge graphs for complementary tooling. Start empowering your AI agents today.

Some links above are affiliate links. dibi8.com may earn a commission if you sign up, at no extra cost to you. Helps keep the site running and the content free.