skill-meta-prompt

# Meta-Prompt Generator Skill

## Overview

Generate well-structured, verifiable prompts for any use case. Applies proven meta-prompting techniques to minimize hallucination and maximize effectiveness.

```
┌─────────────────────────────────────────────────────────────────────────────┐
│                       META-PROMPT GENERATION                                 │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  Phase 1: Requirement Gathering                                             │
│       → Understand the primary goal/role                                    │
│       → Clarify expected outputs                                            │
│       → Identify accuracy requirements                                      │
│       ↓                                                                     │
│  Phase 2: Task Analysis                                                     │
│       → Apply Technique 1: Task Decomposition                               │
│       → Identify if complex enough for subtasks                             │
│       → Map dependencies between subtasks                                   │
│       ↓                                                                     │
│  Phase 3: Expert Assignment                                                 │
│       → Apply Technique 5: Specialized Experts                              │
│       → Assign personas to subtasks                                         │
│       → Apply Technique 2: Fresh Eyes Review                                │
│       ↓                                                                     │
│  Phase 4: Verification Design                                               │
│       → Apply Technique 3: Iterative Verification                           │
│       → Build in checking steps                                             │
│       → Apply Technique 4: No Guessing                                      │
│       ↓                                                                     │
│  Phase 5: Prompt Assembly                                                   │
│       → Structure: Role, Context, Instructions, Constraints, Format         │
│       → Add verification hooks                                              │
│       → Include uncertainty disclaimers                                     │
│       ↓                                                                     │
│  Phase 6: Output & Iteration                                                │
│       → Present generated prompt                                            │
│       → Offer refinement                                                    │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘
```

---

## The Five Techniques

### Technique 1: Task Decomposition

**What:** Break complex tasks into smaller, manageable subtasks.

**When to use:**
- Task has multiple distinct steps
- Different expertise needed for different parts
- Risk of getting lost in complexity

**How to apply:**
1. List all components of the task
2. Identify dependencies (what must happen first)
3. Group related components
4. Order by logical sequence

**Example:**
```
Task: "Create a technical blog post about OAuth 2.0"

Decomposition:
1. Research Phase
   - Gather OAuth 2.0 specifications
   - Find common implementation examples
   - Identify security best practices
   
2. Structure Phase
   - Outline main sections
   - Plan code examples
   - Design diagrams/visuals
   
3. Writing Phase
   - Write introduction
   - Write technical sections
   - Write conclusion/CTA
   
4. Review Phase
   - Technical accuracy check
   - Code example testing
   - Readability review
```

---

### Technique 2: Fresh Eyes Review

**What:** Use different "experts" for creation vs. validation. Never use the same expert to both create and verify.

**When to use:**
- Output needs to be accurate
- Risk of blind spots from creator
- Quality assurance is critical

**How to apply:**
1. Assign Creator Expert for initial work
2. Assign different Reviewer Expert for validation
3. Reviewer should not have seen creation process
4. Loop back to Creator if issues found

**Example:**
```
Creator: "Expert Technical Writer" produces article
Reviewer: "Expert Security Engineer" verifies OAuth claims
Reviewer: "Expert Developer" tests code examples

NOT: Same expert writes AND reviews their own work
```

---

### Technique 3: Iterative Verification

**What:** Build explicit verification steps into the task, especially for error-prone outputs.

**When to use:**
- Mathematical calculations
- Code generation
- Factual claims
- Multi-step reasoning

**How to apply:**
1. After each significant output, add verification step
2. For calculations: "Now verify this by [alternative method]"
3. For code: "Test this code against [test cases]"
4. For claims: "Confirm this by [citing source]"

**Example:**
```
Step 1: Calculate discount price
Step 2: VERIFY - recalculate from opposite direction
Step 3: If mismatch, identify error and recalculate
Step 4: Only proceed when both methods match
```

---

### Technique 4: No Guessing

**What:** Never assume unverified facts. Disclaim uncertainty explicitly.

**When to use:**
- ALWAYS (this is a default behavior)
- Especially for: dates, statistics, quotes, technical specifications

**How to apply:**
1. If uncertain, say "I'm not certain about..."
2. If no data, say "I don't have information on..."
3. Ask for sources rather than inventing
4. Distinguish between "likely" and "confirmed"

**Disclaimer templates:**
```
"Note: This figure is approximate and should be verified."
"I don't have access to [specific data]. Please provide or verify."
"This is based on general patterns; your specific case may differ."
```

---

### Technique 5: Specialized