meta-prompt-framework

# Meta-Prompt Framework Skill

This skill implements a systematic approach to prompt engineering and task execution optimization.

## When This Skill Activates

- Designing prompts for complex tasks
- Implementing multi-phase workflows
- Optimizing LLM task execution
- Creating role-specific instructions
- Building iterative refinement loops

## Three-Phase Task Flow

### Phase 1: Initialization
```yaml
objectives:
  - Analyze task context
  - Clarify overall goal
  - Generate initial outline
  - Prepare inputs for processing

deliverables:
  - Task interpretation
  - Requirements list
  - Preliminary approach

instruction: |
  Prepare inputs for deeper processing and draft
  an initial outline of the solution structure.
```

### Phase 2: Refinement
```yaml
objectives:
  - Refine initial outputs
  - Identify inconsistencies
  - Explore alternatives
  - Ensure modularity

deliverables:
  - Quality-reviewed output
  - Alternative approaches
  - Edge cases identified

instruction: |
  Refine the output to meet quality standards,
  considering modularity and adaptability.
```

### Phase 3: Completion
```yaml
objectives:
  - Finalize against criteria
  - Review constraints
  - Verify structure
  - Generate final output

deliverables:
  - Complete output
  - Compliance check
  - Quality metrics

instruction: |
  Generate the final output, ensuring clarity,
  accuracy, and adherence to the task flow.
```

## Success Criteria

| Criterion | Check |
|-----------|-------|
| Accuracy | Factual correctness verified |
| Consistency | Replicable across executions |
| Clarity | Simple and understandable |
| Efficiency | Completed in reasonable time |

## Refinement Strategies

### Evaluate-Apply-Feedback Loop
1. Evaluate outputs for accuracy/consistency
2. Apply corrections and improvements
3. Generate feedback for context update
4. Iterate until criteria met

### Context Evolution
- Update context files with new insights
- Document improvements for future reference
- Feed learnings back into prompts

## Role Separation

### Task Executor
- Generates outputs following task flow
- Implements three-phase model
- Focuses on deliverable creation

### Task Reviewer
- Reviews for clarity and accuracy
- Checks meta-directive adherence
- Provides improvement suggestions

## Templates

### Phase Template
```markdown
## Phase [N]: [Name]

**Objective:** [What to accomplish]

**Inputs:**
- [Input 1]
- [Input 2]

**Process:**
1. [Step 1]
2. [Step 2]

**Outputs:**
- [Deliverable 1]
- [Deliverable 2]

**Success Criteria:**
- [ ] [Criterion 1]
- [ ] [Criterion 2]
```

### Meta-Directive Template
```yaml
meta_directives:
  [directive_name]:
    priority: [high|medium|low|critical]
    action: "[specific action to take]"
    constraint: "[limitation to observe]"
```

## Best Practices

1. **Phase Gates**: Complete each phase before proceeding
2. **Explicit Criteria**: Define success metrics upfront
3. **Role Clarity**: Separate execution from review
4. **Iteration Limits**: Set maximum refinement cycles
5. **Context Preservation**: Maintain state across phases