Skill Distiller

Trigger Phrases

Methodology solidification, process standardization, experience extraction, pattern refinement, system building.

Philosophy

A good skill turns "fuzzy wisdom" into "clear paths."

The essence of any quality skill is a closed loop: Problem-Driven → Theory Anchored → Process Solidified → Tools Implemented

Workflow (Four-Step Method)

Step 1: Precisely Define the Problem

Goal: Clearly articulate "what exactly is the problem" rather than "what you want to do."

Guiding Questions:

• How often does this problem occur?
• How much time/energy does this problem consume?
• Have you tried to solve it before? How? Where did you get stuck?
• If this problem were completely solved, what changes would it bring?

Output Format:

## Problem Definition

### Problem Description
[State it in one sentence]

### Trigger Scenarios
- Scenario A:
- Scenario B:

### Pain Point Severity
[Rated 1-5], impacting [what]

### Known Attempts
| Solution | Effect | Blockers |
|----------|--------|----------|
| ...      | ...    | ...      |

Step 2: Find Theoretical Support

Goal: Find the "underlying principles" that are documented and logically sound for solving this problem.

Theory Source Priority:

1. Expert Methodologies — Specific practices of domain experts (e.g., STEP framework from Contagious, MECE from The Pyramid Principle)
2. Classic Theories — Frameworks with academic or practical validation (e.g., AIDA, FOGRA, SMART)
3. Industry Consensus — Widely recognized standards in the field
4. Cross-Domain Transfer — Logic validated in other domains, transferred to the current problem

Guiding Questions:

• In this domain, are there recognized experts or books?
• Are there existing frameworks or formulas that can be used?
• If you were to teach someone else, how would you explain it?

Output Format:

## Theoretical Support

### Core Theory
- **Theory Name**: [Name it]
- **Source**: [Book/Course/Expert/Original]
- **Core Idea**: State it in one sentence

### Theory Excerpt
> [Key original text]

### How to Apply the Theory
[How this theory solves your problem]

### Additional References
- Reference A:
- Reference B:

Step 3: Structure the Process

Goal: Turn the theory into an actionable set of steps.

Principles:

• Each step is executable and verifiable
• Clear inputs and outputs
• Closed loop: output of previous step is input of next step
• Fallback plans for exceptions

Guiding Questions:

• What is the first step?
• After completing the first step, how do you know it was done correctly?
• What is the input for the second step?
• Loop until closed

Output Format:

## Process Specification

### Process Overview
[Process Name]: [Starting Point] → [Step 1] → [Step 2] → ... → [Closing Point]

### Detailed Steps

#### Step 1: [Step Name]
- **Input**:
- **Action**:
- **Output**:
- **Success Criteria**: [How to know this step is done well]
- **Exception Handling**: [What to do if something goes wrong]

#### Step 2: [Step Name]
... (same structure as above)

### Closed-Loop Validation
- Can you return to Step 1 from the final step? ✅/❌
- Does each step have a clear output? ✅/❌
- Are exceptions handled? ✅/❌

Step 4: Provide Execution Tools

Goal: Provide tool support for the entire process, enabling automated or semi-automated execution.

Tool Types:

• Information Collection: Search, RSS, crawlers
• Content Generation: Templates, prompts
• Automation Execution: Scripts, workflows
• Storage Management: Note-taking systems, file structures
• Validation: Checklists, evaluation criteria

Guiding Questions:

• Which steps in this process are repetitive?
• Which steps can be templated?
• Which steps are currently the most time-consuming?
• To what extent do you want automation?

Output Format:

## Execution Tools

### Tool Inventory
| Tool | Type | Purpose | Automation Level |
|------|------|---------|------------------|
| ...  | ...  | ...     | ...              |

### Prompt Templates
#### [Scenario Name]

[Prompt text]

### Templates/Checklists
#### [Template Name]

[Template content]

### Automation Scripts
- Script Path: [Path]
- Function: [What it does]
- Usage: [How to use it]

Skill Output Summary

After completing the four steps, aggregate the output into an executable SKILL.md draft:

## [Skill Name]

**One-sentence description**: [What problem does this skill solve]

**Applicable Scenarios**:
- ...

**Process**: Problem → Theory → Process → Tools (detailed in respective sections)

---
[Paste the content from each section here]

Usage Tips

1. Don't have to complete all four steps: If the user only wants to do one step (e.g., only define the problem), just do that step
2. Iterate and refine: Start with a rough version, then refine after using it a few times
3. Start small: Distill a small problem first, then gradually expand
4. Don't overdo tools: One handy tool is more valuable than ten fancy ones
5. Be specific about the problem: "I write slowly" is not a problem; "It takes me 2 hours just to figure out the opening for each short video script" is a problem