---
name: 02-meta-skill-forge-150
description: "[02] META. Create new skills when existing ones don't cover the task. Analyze unique requirements, build framework (Frame → Research → Plan → Execute), integrate risks, and declare new skill. Use when facing novel problems that existing skills can't address."
---

# Meta-Skill-Forge 150 Protocol

**Core Principle:** When existing skills don't fit, forge a new one. Analyze the unique task, build a proper framework, integrate specific risks, and create a reusable skill.

## What This Skill Does

When you invoke this skill, you're asking AI to:
- **Identify the gap** — Why existing skills don't cover this
- **Analyze requirements** — What makes this task unique
- **Build framework** — Frame → Research → Plan → Execute
- **Integrate risks** — Handle specific challenges
- **Declare new skill** — Create reusable, documented skill

## The 150% Forge Rule

| Dimension | 100% Core | +50% Enhancement |
|-----------|-----------|------------------|
| **Framework** | Basic structure | + Task-specific adaptations |
| **Criteria** | Success metrics | + Quality checkpoints |
| **Risks** | Known challenges | + Mitigation strategies |
| **Evolution** | Current version | + Improvement path |

## When to Use This Skill

**TRIGGER:** Task is outside existing skill coverage:
- Existing skills don't apply
- Combination of skills isn't enough
- Novel problem type encountered
- Repeated pattern needs formalization

**DO NOT USE FOR:**
- ❌ Tasks covered by existing skills
- ❌ Simple problems (over-engineering)
- ❌ One-off situations (not worth formalizing)

## Skill Construction Framework

```
FRAMEWORK FOUNDATION (100% Required)
├── Task Semantics: Core requirements analysis
├── Structure: Frame → Research → Plan → Execute
├── Criteria: Success and quality metrics
└── Validation: How to verify skill works

ADAPTATION LAYER (50% Enhancement)
├── Risk Integration: Specific challenge handling
├── Spirit Alignment: Task-appropriate approach
├── Resource Optimization: Efficient methods
└── Evolution Planning: Future improvements
```

## Execution Protocol

### Step 1: GAP ANALYSIS
```
🔍 **GAP ANALYSIS**

**Task:** [What needs to be done]

**Existing Skills Checked:**
- [ ] goal-clarity-150: [Fits/Doesn't fit - why]
- [ ] research-deep-150: [Fits/Doesn't fit - why]
- [ ] impact-map-150: [Fits/Doesn't fit - why]
- [ ] action-plan-150: [Fits/Doesn't fit - why]
- [ ] chain-flow-150: [Fits/Doesn't fit - why]
- [ ] [Other skills...]: [Assessment]

**Gap Identified:** [What's missing]
**New Skill Justified:** ✅ Yes | ❌ No (use existing)
```

### Step 2: REQUIREMENTS ANALYSIS
```
📋 **UNIQUE REQUIREMENTS**

**What makes this task special:**
- [Unique aspect 1]
- [Unique aspect 2]
- [Unique aspect 3]

**Core challenges:**
- [Challenge 1]
- [Challenge 2]

**Success looks like:**
- [Success criterion 1]
- [Success criterion 2]

**Failure looks like:**
- [Failure mode 1]
- [Failure mode 2]
```

### Step 3: FRAMEWORK CONSTRUCTION
```
🏗️ **SKILL FRAMEWORK**

**Skill Name:** [name-150]
**Purpose:** [One-line description]

**STRUCTURE:**

FRAME PHASE:
├── [Setup step 1]
├── [Setup step 2]
└── [Context establishment]

RESEARCH PHASE:
├── [Investigation step 1]
├── [Investigation step 2]
└── [Information synthesis]

PLAN PHASE:
├── [Strategy step 1]
├── [Strategy step 2]
└── [Preparation completion]

EXECUTE PHASE:
├── [Implementation step 1]
├── [Implementation step 2]
└── [Validation and completion]
```

### Step 4: RISK INTEGRATION
```
⚠️ **RISK HANDLING**

**Specific Risks:**
| Risk | Likelihood | Impact | Mitigation |
|------|------------|--------|------------|
| [Risk 1] | [H/M/L] | [H/M/L] | [Strategy] |
| [Risk 2] | [H/M/L] | [H/M/L] | [Strategy] |

**Built-in Safeguards:**
- [Safeguard 1]
- [Safeguard 2]

**Recovery Paths:**
- If [failure]: [recovery action]
- If [failure]: [recovery action]
```

### Step 5: QUALITY ASSURANCE
```
✅ **QUALITY CHECKPOINTS**

**Validation Methods:**
- [ ] [How to verify step 1 works]
- [ ] [How to verify step 2 works]
- [ ] [How to verify overall skill works]

**Success Metrics:**
- [Metric 1]: [How to measure]
- [Metric 2]: [How to measure]

**Quality Gates:**
- After Frame: [What must be true]
- After Research: [What must be true]
- After Plan: [What must be true]
- After Execute: [What must be true]
```

### Step 6: SKILL DECLARATION
```
⚡ **NEW SKILL DECLARED**

---
name: [skill-name-150]
description: [One-line description for skill discovery]
---

# [Skill Name] 150 Protocol

**Core Principle:** [Main idea in one sentence]

## What This Skill Does
[Bullet list of capabilities]

## The 150% Rule
[Table of 100% core + 50% enhancement]

## When to Use
[Trigger conditions]

## Execution Protocol
[Step-by-step process]

## Output Format
[Expected outputs]

## Operational Rules
[Numbered rules]

## Failure Modes & Recovery
[Table of failures and recoveries]

## Examples
[Good and bad examples]
```

### Step 7: USER APPROVAL
```
📝 **SKILL-FORGE 150 PROPOSAL**

**New Skill:** [name-150]
**Purpose:** [Description]
**Fills Gap:** [What was missing]

**Structure Summary:**
- Frame: [Brief]
- Research: [Brief]
- Plan: [Brief]
- Execute: [Brief]

**Approve skill creation?** (Yes / No / Modify)
```

## Output Format

Proposal:
```
⚡ **SKILL-FORGE 150 PROPOSAL**

**Gap Identified:** [What existing skills don't cover]

**New Skill:**
├── Name: [skill-name-150]
├── Purpose: [One-line description]
└── Unique Value: [What it adds]

**Framework:**
├── Frame: [Summary]
├── Research: [Summary]
├── Plan: [Summary]
└── Execute: [Summary]

**Risks Addressed:**
- [Risk 1] → [Mitigation]
- [Risk 2] → [Mitigation]

**Approve creation?**
```

Complete skill file ready to save.

## Skill File Template

```markdown
---
name: [skill-name-150]
description: [One-line description that helps skill discovery. Include trigger words and use cases.]
---

# [Skill Name] 150 Protocol

**Core Principle:** [Main idea]

## What This Skill Does

When you invoke this skill, you're asking AI to:
- [Capability 1]
- [Capability 2]
- [Capability 3]

## The 150% Rule

| Dimension | 100% Core | +50% Enhancement |
|-----------|-----------|------------------|
| [Dim 1] | [Core] | [Enhancement] |
| [Dim 2] | [Core] | [Enhancement] |

## When to Use This Skill

- [Trigger 1]
- [Trigger 2]
- [Trigger 3]

## Execution Protocol

### Step 1: [NAME]
[Details]

### Step 2: [NAME]
[Details]

[Continue as needed]

## Output Format

[Template for skill output]

## Operational Rules

1. [Rule 1]
2. [Rule 2]
3. [Rule 3]

## Failure Modes & Recovery

| Failure | Detection | Recovery |
|---------|-----------|----------|
| [Failure 1] | [How to detect] | [How to fix] |
| [Failure 2] | [How to detect] | [How to fix] |

## Examples

### ❌ Without This Skill
[Bad example]

### ✅ With This Skill
[Good example]

---

**Remember:** [Key takeaway]
```

## Operational Rules

1. **UNIQUENESS REQUIRED:** Only forge when existing skills don't cover
2. **FOUNDATION FIRST:** Always use Frame → Research → Plan → Execute
3. **RISK AWARENESS:** Explicitly handle specific challenges
4. **QUALITY ASSURANCE:** Build in validation and checkpoints
5. **DOCUMENTATION:** Complete skill specification
6. **EVOLUTION PLANNING:** Leave path for future improvements

## Failure Modes & Recovery

| Failure | Detection | Recovery |
|---------|-----------|----------|
| **Over-Engineering** | Too complex for task | Simplify to essentials |
| **Incomplete Coverage** | Missing key aspects | Expand framework scope |
| **Poor Adaptation** | Doesn't fit task spirit | Re-align with requirements |
| **No Validation** | Can't verify it works | Add testing and feedback |

## Examples

### ❌ Bad Skill-Forge
```
Task: Rename a variable
Gap: "No variable-rename-150 skill!"
Result: Created 20-step protocol for simple find-replace
Outcome: Over-engineering, wasted effort
```

### ✅ Good Skill-Forge
```
⚡ SKILL-FORGE 150 PROPOSAL

Gap Identified: No skill for zero-downtime data migrations

New Skill:
├── Name: live-migrate-150
├── Purpose: Execute data migrations without service interruption
└── Unique Value: Combines deployment, monitoring, and rollback

Framework:
├── Frame: Assess data volumes, set up shadow tables
├── Research: Analyze dependencies, identify sync points
├── Plan: Design phased migration with validation gates
└── Execute: Migrate incrementally with real-time verification

Risks Addressed:
- Data inconsistency → Dual-write with reconciliation
- Performance impact → Throttled batch processing
- Rollback needed → Point-in-time recovery points

Approve creation? Yes

[Full SKILL.md created and saved]
```

## Relationship to Other Skills

- **chain-flow-150** → Orchestrates existing skills
- **skill-forge-150** → Creates new skills when needed
- **All other skills** → Become available for chain-flow

---

**Remember:** Skill-forge is for genuine gaps, not for making simple things complex. A well-forged skill becomes a reusable asset. A poorly-forged skill becomes technical debt. Forge wisely.