How to Use Claude Skills for Development and Code Assistance: A Complete Guide

Claude Skills are self-contained instruction packages—hosted in structured SKILL.md files—that tell AI agents how to perform specific development tasks, from managing OAuth connections to orchestrating multi-sub-agent coding workflows, with instructions loading on-demand to preserve context window efficiency.

The ComposioHQ/awesome-claude-skills repository provides a production-ready framework for extending Claude Code and the Claude API beyond simple code generation into full-stack development automation. These skills integrate with the Model Context Protocol (MCP) to enable secure interactions with external APIs, database updates, and GitHub operations while maintaining token-efficient context management through catalog-based loading.

Architecture of Claude Skills

Each skill lives in its own folder and contains a SKILL.md file with YAML front-matter describing the skill's name and purpose, plus the full instruction body that Claude loads when the user’s query matches the skill’s description. According to the source code in README.md (lines 99–106), this architecture allows an agent to host thousands of skills without exhausting its context window by streaming only the relevant skill data after initial catalog matching.

The Three-Layer Execution Stack

The execution model consists of three distinct layers that separate concerns between transport, function, and orchestration:

• MCP (Model Context Protocol) Server: Provides secure, token-based access to external APIs, handling authentication, transport, and service discovery.
• Tools: Individual functions the agent can invoke, such as “send Slack message” or “create GitHub issue.”
• Skills: Orchestrate complete workflows by specifying which tools to call, in what order, and with what guardrails for complex development tasks.

On-Demand Loading Mechanism

When Claude starts a session, it initially sees only the skill catalog (approximately 100 tokens per skill). If the user’s query matches a skill’s description, the full SKILL.md content is streamed to the model along with any auxiliary scripts. As implemented in README.md (lines 101–104), this lazy-loading pattern ensures the agent maintains access to extensive tool libraries without upfront token consumption.

Essential Development Skills in the Repository

The awesome-claude-skills collection ships with several production-ready skills specifically designed for software development workflows:

• connect: Enables Claude to perform real actions including sending email, creating GitHub issues, posting to Slack, and updating databases. It wires the agent to Composio’s MCP gateway with automatic OAuth handling, defined in connect/SKILL.md (lines 1–18).
• subagent-driven-development: Dispatches independent sub-agents for discrete coding tasks, inserting code-review checkpoints between iterations for rapid, controlled development cycles, referenced in README.md (line 148).
• test-driven-development: Guides the agent to write failing tests first, then implements code to satisfy them, creating a structured TDD loop as noted in README.md (lines 149–150).
• lean-ctx: Provides session-caching and AST-aware compression, dramatically reducing token usage when working with large codebases, documented in README.md (lines 135–136).
• mcp-builder: Helps developers spin up custom MCP servers in Python or TypeScript to expose any internal API as a Claude-compatible tool, located in mcp-builder/SKILL.md and referenced in README.md (lines 136–137).

How to Deploy Claude Skills for Code Assistance

You can leverage these skills through three primary integration methods: Claude Code CLI, the Claude AI interface, or direct API integration.

Installing Skills in Claude Code CLI

To use a skill in the terminal-based Claude Code environment, copy the skill folder to the local skills directory:

# Create the skills directory if it doesn't exist

mkdir -p ~/.config/claude-code/skills/

# Install the connect skill (or any skill folder)

cp -r /path/to/awesome-claude-skills/connect ~/.config/claude-code/skills/

# Verify the skill metadata

head ~/.config/claude-code/skills/connect/SKILL.md

# Launch Claude Code

claude

Once installed, reference the skill naturally in your prompt: “Send an email to sarah@acme.com with subject ‘Release v2.0’ and body ‘The new version is live.’” Claude automatically routes the request through the connect skill to execute the action.

Invoking Skills via the Claude API (Python)

For programmatic access, pass the skill identifier to the skills parameter when creating messages. According to connect/SKILL.md (lines 63–71), this injects the skill’s tool definitions directly into the model context:

import anthropic

client = anthropic.Anthropic(api_key="YOUR_API_KEY")

response = client.messages.create(
    model="claude-3-5-sonnet-20241022",
    skills=["connect"],  # Loads the Connect skill catalog and instructions

    messages=[{
        "role": "user",
        "content": "Create a GitHub issue in repo my-org/my-repo: 'Bug: login fails on Safari'"
    }],
)

print(response.content)

The skills parameter ensures Claude understands the available tool schemas immediately, allowing it to generate proper function calls for the GitHub API without few-shot prompting.

Running Sub-Agent Driven Development

For complex implementation tasks, the subagent-driven-development skill orchestrates multiple Claude instances to divide and conquer:

# Ensure the skill is installed in ~/.config/claude-code/skills/

claude

Prompt: “Implement a new function calculateDiscount(price: float) -> float that applies a 10% discount for orders over $100.”

Claude spawns a sub-agent to draft the function implementation, then triggers a review sub-agent to validate against style guidelines and generated tests, iterating until the checkpoint passes. This workflow, defined in the external subagent-driven-development reference, keeps the main agent’s context clean while delegating implementation details.

Key Source Files and Implementation Details

Understanding these core files helps when customizing or debugging skill behavior:

• README.md: Contains the architectural overview, skill catalog specifications, and onboarding instructions for the repository.
• connect/SKILL.md: The canonical reference for action-enabled skills, demonstrating YAML front-matter structure and OAuth integration patterns.
• connect-apps-plugin/.claude-plugin/plugin.json: Plugin manifest for installing the Connect skill as a Claude AI marketplace extension.
• mcp-builder/SKILL.md: Provides templates and instructions for creating custom MCP servers to expose proprietary APIs as Claude tools.

Summary

• Claude Skills are modular instruction packages that extend Claude's capabilities through SKILL.md files with YAML metadata and detailed execution instructions.
• Skills load on-demand from a lightweight catalog, preserving context window space while providing access to thousands of potential tools.
• The three-layer stack (MCP Server → Tools → Skills) separates transport security from function logic from workflow orchestration.
• Development-specific skills include connect for external API actions, subagent-driven-development for parallel coding tasks, and test-driven-development for structured testing workflows.
• Integration options span Claude Code CLI (directory-based), Claude AI UI (plugin marketplace), and the Python API (programmatic skills parameter).

Frequently Asked Questions

How do Claude Skills differ from standard system prompts?

Standard system prompts provide static instructions for every conversation, while Claude Skills are modular and dynamically loaded based on user intent. Skills reside in isolated folders (SKILL.md) and only inject their full instruction set when the conversation context requires specific tools, preventing token waste and allowing specialization across thousands of distinct capabilities.

Can I use Claude Skills with the Claud API or only Claude Code?

Claude Skills function in both environments. In Claude Code, skills auto-load from ~/.config/claude-code/skills/. When using the Claude API, you explicitly pass skill identifiers to the skills parameter in your request, as demonstrated in the Python SDK examples using anthropic.Anthropic().messages.create().

What is the Model Context Protocol (MCP) in Claude Skills?

The Model Context Protocol is the secure transport layer that sits below Skills and Tools in the execution stack. According to the repository architecture, MCP servers handle OAuth flows, API authentication, and transport encryption, allowing Claude to safely interact with external services like GitHub, Slack, and databases without exposing credentials in the prompt context.

How do I create a custom skill for my internal API?

Use the mcp-builder skill included in the repository. This skill provides templates and step-by-step instructions for generating custom MCP servers in Python or TypeScript. Once built, you package the server configuration with a SKILL.md file describing available tools, enabling Claude to discover and invoke your internal APIs using the standard three-layer architecture.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}