How Claude Skills Interact with Tool Use and Function Calling: A Technical Deep Dive

Claude Skills are high-level instruction packages that orchestrate agent workflows, while tools are executable functions exposed via the Model Context Protocol (MCP) that Claude invokes through native function calling to bridge declarative intents with concrete actions.

In the ComposioHQ/awesome-claude-skills repository, the relationship between Skills, tools, and function calling forms a three-layer architecture that transforms Claude from a text generator into an action-taking agent. Understanding how Claude Skills interact with tool use and function calling is essential for building production AI agents that can manipulate external APIs, databases, and services through structured, type-safe interfaces.

Skills vs. Tools: Understanding the Architectural Boundary

The fundamental distinction between these components determines how you architect agentic systems.

What Are Claude Skills?

Claude Skills are declarative, markdown-based instruction packages that define what an agent should accomplish. According to the repository's README.md, "Skills are not MCP servers and not tools… Tools are the individual functions an agent invokes… Skills define the workflow"【^1^】. A Skill acts as a high-level router, providing context, guardrails, and step-by-step guidance that helps Claude decide when to take external actions.

What Are Tools in the MCP Ecosystem?

Tools are the executable functions exposed by MCP servers. Each tool advertises a strict schema—name, description, and input parameters—that allows clients to discover and invoke capabilities via standardized endpoints. As documented in mcp-builder/reference/mcp_best_practices.md, MCP servers expose tools through the tools/call endpoint, accepting JSON payloads that match predefined input schemas【^2^】.

How Function Calling Bridges the Gap

Modern Claude models support OpenAI-style function calling, allowing the model to automatically select appropriate tools, populate parameters from natural language context, and generate structured JSON payloads for execution. When a Skill's instructions reference an external action—such as "send an email" or "create a GitHub issue"—Claude uses its function calling capability to map that intent to a specific MCP tool definition.

The Execution Pipeline: From Skill Intent to Tool Action

When Claude processes a Skill, the interaction follows a predictable three-phase pipeline that leverages tool use capabilities.

Phase 1: Skill Context Loading

The Skill package loads into Claude's context window, providing system-level instructions. For example, the connect Skill documented in connect/SKILL.md instructs Claude on when to trigger external tools—such as "send a Slack message" or "create a GitHub issue"—without defining the underlying implementation details【^3^】.

Phase 2: Tool Discovery and Selection

Claude queries the MCP server to list available tools. Each tool definition includes:

• Name: The unique identifier (e.g., slack.sendMessage)
• Input schema: Required parameters and their types
• Description: Natural language explanation of functionality

Phase 3: Function Invocation

Upon identifying the need for external action, Claude generates a function call payload. The client—whether the Claude SDK or a custom implementation—routes this to the MCP server's tools/call endpoint, executes the function, and returns the result to the conversation context.

Practical Implementation: Calling Tools from Skills

Implementing this architecture requires configuring the MCP client and structuring Skills to leverage function calling.

Example 1: Using the Connect Skill with Python

The following implementation demonstrates how the connect Skill triggers tool calls through the Claude SDK:

from composio import Composio
from claude_agent_sdk.client import ClaudeSDKClient
from claude_agent_sdk.types import ClaudeAgentOptions
import os

# Initialize Composio MCP session

composio = Composio(api_key=os.getenv("COMPOSIO_API_KEY"))
session = composio.create(user_id="demo_user")

# Configure Claude SDK to communicate with MCP server

options = ClaudeAgentOptions(
    system_prompt="You can take actions in external apps.",
    mcp_servers={
        "composio": {
            "type": "http",
            "url": session.mcp.url,
            "headers": {"x-api-key": os.getenv("COMPOSIO_API_KEY")},
        }
    },
)

# Execute Skill that triggers tool use

async with ClaudeSDKClient(options) as client:
    await client.query(
        """
        # Using the Connect Skill

        Post to #general on Slack: "Deploy complete – version 2.4.0 live"
        """
    )

How it works: The Skill's markdown instructs Claude to "Post to #general", triggering function calling to identify the slack.sendMessage tool. The SDK maps the intent to the MCP definition, fills the channel and text parameters, and executes via the tools/call endpoint.

Example 2: Defining a Custom Arithmetic Skill

This example illustrates how Skills embed tool specifications for function calling:

Tool Definition (my-math-tool.json):

{
  "name": "math.add",
  "description": "Add two numbers",
  "inputSchema": {
    "type": "object",
    "properties": {
      "a": { "type": "number" },
      "b": { "type": "number" }
    },
    "required": ["a", "b"]
  },
  "annotations": { "readOnlyHint": true }
}

Skill Package (my-math-skill/SKILL.md):

---
name: my-math-skill
description: Demonstrates a Skill that uses a custom arithmetic tool.
---

# Add Two Numbers

When you need the sum of two numbers:

Add {{a}} and {{b}} using the math.add tool.

Execution flow: Claude receives the Skill template, substitutes variables from user input, generates a function call to math.add with the populated schema, and awaits the MCP server's result before continuing the conversation.

Key Source Files in the Repository

Understanding the implementation requires referencing these specific files:

• README.md: Establishes the conceptual distinction between Skills, Tools, and MCP servers, clarifying that Skills define workflow while tools define execution mechanics【^1^】.

• mcp-builder/reference/mcp_best_practices.md: Documents the tool definition schema, discovery protocols, and the tools/call invocation flow required for function calling integration【^2^】.

• connect/SKILL.md: Provides a concrete production example where a Skill routes user intents—such as sending emails or creating GitHub issues—to underlying Composio-provided tools through structured tool calls【^3^】.

Summary

• Claude Skills are high-level markdown packages that orchestrate agent behavior and define when to take actions, not how to execute them.

• MCP Tools are typed, executable functions exposed via servers, discovered through standardized endpoints, and invoked via the tools/call interface.

• Function Calling enables Claude to automatically translate Skill instructions into structured tool invocations, bridging natural language intent with machine-executable API calls.

• The connect Skill demonstrates production integration, delegating user requests to specific tools like slack.sendMessage while the Skill manages context and workflow logic.

• Proper implementation requires configuring MCP server connections in the Claude SDK and ensuring tool schemas align with the parameters referenced in Skill templates.

Frequently Asked Questions

What is the difference between a Claude Skill and an MCP tool?

A Claude Skill is a declarative instruction set that guides the agent's decision-making and workflow orchestration, while an MCP tool is a concrete executable function with a strict input schema. As stated in the repository's README.md, Skills define what workflow to execute, whereas tools define how to perform specific actions【^1^】.

How does Claude know which tool to call when executing a Skill?

Claude uses its native function calling capability to match the Skill's natural language instructions against available tool definitions. When the Skill describes an action like "send a Slack message," Claude compares this intent against the tool descriptions and input schemas exposed by the MCP server, then generates the appropriate JSON payload for the tools/call endpoint.

Can I use Claude Skills without MCP servers?

While Skills can function as pure prompt engineering packages for text-based reasoning, they cannot perform external actions without MCP servers. The Skill-to-Tool interaction requires an MCP server to expose executable functions; without it, the Skill remains limited to conversational responses rather than real-world actions.

What role does function calling play in the Skill execution pipeline?

Function calling acts as the translation layer between the Skill's high-level instructions and the MCP tool's typed interface. When a Skill triggers an action, Claude generates a function call payload containing the tool name and parameters, which the client then routes to the MCP server. This mechanism allows Skills to remain declarative while leveraging Claude's ability to extract structured data from context for API execution.

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