# How Skills Are Triggered by User Conversation in Knowledge Work Plugins

> Understand how skills trigger via user conversation. Claude matches utterances to skill descriptions in SKILL.md, selecting the best match for execution. Learn more now.

- Repository: [Anthropic/knowledge-work-plugins](https://github.com/anthropics/knowledge-work-plugins)
- Tags: internals
- Published: 2026-06-01

---

**Skills are triggered automatically when Claude matches user utterances against natural-language "When to use" descriptions defined in each skill's [`SKILL.md`](https://github.com/anthropics/knowledge-work-plugins/blob/main/SKILL.md) file, selecting the highest relevance match for execution.**

In the `anthropics/knowledge-work-plugins` repository, skills represent self-contained units of functionality that activate based on conversational context. Understanding how skills triggered by user conversation actually work requires examining the declarative trigger mechanism and the runtime execution flow that connects user intent to code execution.

## The 5-Step Activation Flow

When a user sends a message, the system evaluates potential skills through a structured pipeline that bridges natural language understanding with programmatic execution.

### 1. Conversation Capture and Plugin Registration

Every user utterance is sent to Claude together with the list of installed plugins. The runtime code in [`productivity/.claude-plugin/plugin.json`](https://github.com/anthropics/knowledge-work-plugins/blob/main/productivity/.claude-plugin/plugin.json) registers each skill's endpoint and makes the installed skill inventory available to the language model.

### 2. Relevance Scoring Against Declarative Triggers

Claude evaluates the utterance against each skill's relevance description found in the *"When to use"* section of the skill's [`SKILL.md`](https://github.com/anthropics/knowledge-work-plugins/blob/main/SKILL.md). For example, in [`sales/skills/create-an-asset/SKILL.md`](https://github.com/anthropics/knowledge-work-plugins/blob/main/sales/skills/create-an-asset/SKILL.md), the trigger description might read: "Ask the user for a new sales outreach draft. Typical phrasing: 'Help me write an email to a prospect about our new feature.'"

The model reasons about intent, required context, and explicit keywords to generate a relevance score.

### 3. Skill Selection with Disambiguation

The skill with the highest relevance score is chosen. If multiple skills return viable scores—as seen in [`sales/skills/create-an-asset/SKILL.md`](https://github.com/anthropics/knowledge-work-plugins/blob/main/sales/skills/create-an-asset/SKILL.md) logic—Claude may ask the user to clarify which skill to run before proceeding.

### 4. Execution Request Generation

Once selected, Claude emits a **skill-execution request** (a JSON payload) that includes the skill name, extracted parameters, and optionally an `AskUserQuestion` step to gather missing information.

### 5. Backend Execution

The backend receives the request, loads the skill bundle (`.skill` zip), and runs the code inside the skill's `scripts/` folder. For example, [`bio-research/skills/single-cell-rna-qc/scripts/qc_core.py`](https://github.com/anthropics/knowledge-work-plugins/blob/main/bio-research/skills/single-cell-rna-qc/scripts/qc_core.py) executes the actual quality control logic. Results are returned to Claude, which formats the final response.

## Declarative Triggers in SKILL.md Files

Skill authors define triggers conversationally rather than programmatically. The [`SKILL.md`](https://github.com/anthropics/knowledge-work-plugins/blob/main/SKILL.md) file uses natural language to describe the problem space.

```markdown

## When to use

Ask the user for a new sales outreach draft.  
Typical phrasing: "Help me write an email to a prospect about our new feature."

```

Claude interprets this description as a *soft trigger*. When a user says something semantically similar like "Write a cold email for our latest AI product," the model matches this intent to the skill in [`sales/skills/create-an-asset/SKILL.md`](https://github.com/anthropics/knowledge-work-plugins/blob/main/sales/skills/create-an-asset/SKILL.md).

## Dynamic Context and AskUserQuestion Nodes

Skills can specify required external data such as conversation history or calendar events. When data is missing, the skill annotates the request with an `AskUserQuestion` node, prompting the user before execution.

```json
{
  "type": "AskUserQuestion",
  "question": "Which prospect are you reaching out to?",
  "options": ["Skip"]
}

```

This JSON structure injects a UI element into the conversational flow, ensuring the skill receives all required parameters before the backend loads and executes the skill bundle.

## Memory-Based Continuity and Priority Rules

The system maintains context through the memory-management skill defined in [`productivity/skills/memory-management/SKILL.md`](https://github.com/anthropics/knowledge-work-plugins/blob/main/productivity/skills/memory-management/SKILL.md). This skill stores salient facts from previous turns, and subsequent utterances referencing those facts automatically raise the relevance score of any skill consuming that memory.

Skills declaring themselves as *"core"* (such as the "Start" skill in [`productivity/skills/start/SKILL.md`](https://github.com/anthropics/knowledge-work-plugins/blob/main/productivity/skills/start/SKILL.md)) receive priority evaluation, ensuring critical bootstrap functionality runs first. If no skill meets the confidence threshold, Claude falls back to a generic conversational response.

## Skill Execution Request Format

When Claude determines a skill should run, it generates a structured request that bridges the conversational layer and the execution backend.

```json
{
  "skill": "sales/create-an-asset",
  "action": "run",
  "parameters": {
    "asset_type": "email",
    "prospect_name": "Acme Corp"
  }
}

```

The backend parses this payload, locates the corresponding `.skill` archive, extracts the code, and runs the relevant scripts. The results flow back through Claude to reach the user as a naturally formatted response.

## Summary

- Skills triggered by user conversation rely on **natural-language matching** between user utterances and the "When to use" sections in [`SKILL.md`](https://github.com/anthropics/knowledge-work-plugins/blob/main/SKILL.md) files.
- **Relevance scoring** occurs in real-time, with Claude evaluating intent against all installed skills registered in [`.claude-plugin/plugin.json`](https://github.com/anthropics/knowledge-work-plugins/blob/main/.claude-plugin/plugin.json).
- **Missing parameters** trigger `AskUserQuestion` nodes that gather required data before backend execution.
- **Memory continuity** from previous conversations influences current relevance scores through the memory-management skill.
- **Core skills** receive priority evaluation, and execution ultimately runs code from the skill's `scripts/` directory.

## Frequently Asked Questions

### What file defines when a skill should be triggered?

Each skill's trigger logic is defined in its [`SKILL.md`](https://github.com/anthropics/knowledge-work-plugins/blob/main/SKILL.md) file, specifically within the "When to use" section. This file uses conversational language to describe the scenarios where the skill applies, allowing Claude to perform semantic matching against user inputs.

### How does Claude handle ambiguous user requests?

When multiple skills return similar relevance scores—such as when a user request could refer to either drafting an asset or starting a productivity session—Claude requests clarification from the user before executing any skill. This disambiguation logic ensures the correct skill runs based on user intent.

### What happens if a skill needs additional information to run?

The skill execution request includes an `AskUserQuestion` node that prompts the user for missing required data. This interaction occurs before the backend loads the skill bundle, ensuring all necessary parameters are available when the code in `scripts/` actually executes.

### Where is the skill code actually executed?

After Claude generates the execution request, the backend receives the payload, loads the skill bundle (a `.skill` zip file), and runs the code located in the skill's `scripts/` folder. For example, scientific workflows execute through scripts like [`bio-research/skills/single-cell-rna-qc/scripts/qc_core.py`](https://github.com/anthropics/knowledge-work-plugins/blob/main/bio-research/skills/single-cell-rna-qc/scripts/qc_core.py).