skill-meta-prompt

What this skill does

> **Host: Codex CLI** — This skill was designed for Claude Code and adapted for Codex.
> Cross-reference commands use installed skill names in Codex rather than `/octo:*` slash commands.
> Use the active Codex shell and subagent tools. Do not claim a provider, model, or host subagent is available until the current session exposes it.
> For host tool equivalents, see `skills/blocks/codex-host-adapter.md`.


# 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 Experts

**What:** Spawn domain-specific personas for complex subtasks.

**When to use:**
- Task requires specialized knowledge
- Different perspectives would improve quality
- Cross-functional work needed

**Available expert archetypes:**
| Expert | Use For |
|--------|---------|
| Expert Writer | Content, copy, documentation |
| Expert Mathematician | Calculations, proofs, statistics |
| Expert Python | Python code, data analysis |
| Expert Security | Security review, threat modeling |
| Expert Architect | System design, trade-offs |
| Expert Reviewer | Quality assurance, error-finding |
| Expert Strategist | Planning, prioritization |

**How to apply:**
```
"For this subtask, adopt the persona of Expert [X].
Your expertise includes [specific areas].
Focus exclusively on [your assigned task].
You have no memory of previous context—all needed information is below."
```


## Phase 1: Requirement Gathering

### Initial Prompt

```markdown
**Meta-Prompt Generator**

I'll help you create an effective, verifiable prompt.

**Questions:**

1. **What is the main goal?**
   What should this prompt help someone accomplish?

2. **What's the expected output?**
   (e.g., document, code, analysis, decision)

3. **How important is accuracy?**
   - Critical (factual, technical, or high-stakes)
   - Moderate (useful but not mission-critical)
   - Flexible (creative, exploratory)

4. **Any specific constraints?**
   (length, format, tone, tools available)
```

### Minimum Information Needed

- Primary goal (REQUIRED)
- Output type (REQUIRED)
- Accuracy requirements (can assume moderate)
- Constraint