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

> Understand how Claude Skills orchestrate agent workflows and interact with Claude's tool use and function calling for concrete actions. Technical deep dive.

- Repository: [Composio/awesome-claude-skills](https://github.com/composiohq/awesome-claude-skills)
- Tags: deep-dive
- Published: 2026-07-26

---

**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`](https://github.com/ComposioHQ/awesome-claude-skills/blob/main/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`](https://github.com/ComposioHQ/awesome-claude-skills/blob/main/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`](https://github.com/ComposioHQ/awesome-claude-skills/blob/main/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:

```python
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`](https://github.com/ComposioHQ/awesome-claude-skills/blob/main/my-math-tool.json)):

```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`](https://github.com/ComposioHQ/awesome-claude-skills/blob/main/my-math-skill/SKILL.md)):

```markdown
---
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`](https://github.com/ComposioHQ/awesome-claude-skills/blob/main/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`](https://github.com/ComposioHQ/awesome-claude-skills/blob/main/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`](https://github.com/ComposioHQ/awesome-claude-skills/blob/main/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`](https://github.com/ComposioHQ/awesome-claude-skills/blob/main/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.