create-meta-prompts

Create prompts optimized for Claude-to-Claude communication in multi-stage workflows. Outputs are structured with XML and metadata for efficient parsing by subsequent prompts.

Every execution produces a SUMMARY.md for quick human scanning without reading full outputs.

Each prompt gets its own folder in .prompts/ with its output artifacts, enabling clear provenance and chain detection.

1. Intake: Determine purpose (Do/Plan/Research/Refine), gather requirements
2. Chain detection: Check for existing research/plan files to reference
3. Generate: Create prompt using purpose-specific patterns
4. Save: Create folder in .prompts/{number}-{topic}-{purpose}/
5. Present: Show decision tree for running
6. Execute: Run prompt(s) with dependency-aware execution engine
7. Summarize: Create SUMMARY.md for human scanning

```

.prompts/

├── 001-auth-research/

│ ├── completed/

│ │ └── 001-auth-research.md # Prompt (archived after run)

│ ├── auth-research.md # Full output (XML for Claude)

│ └── SUMMARY.md # Executive summary (markdown for human)

├── 002-auth-plan/

│ ├── completed/

│ │ └── 002-auth-plan.md

│ ├── auth-plan.md

│ └── SUMMARY.md

├── 003-auth-implement/

│ ├── completed/

│ │ └── 003-auth-implement.md

│ └── SUMMARY.md # Do prompts create code elsewhere

├── 004-auth-research-refine/

│ ├── completed/

│ │ └── 004-auth-research-refine.md

│ ├── archive/

│ │ └── auth-research-v1.md # Previous version

│ └── SUMMARY.md

```

Prompts directory: !ls -d .prompts 2>/dev/null

Existing prompts: !ls .prompts 2>/dev/null

BEFORE analyzing anything, check if context was provided.

IF no context provided (skill invoked without description):

→ IMMEDIATELY use AskUserQuestion with:

• header: "Purpose"
• question: "What is the purpose of this prompt?"
• options:

- "Do" - Execute a task, produce an artifact

- "Plan" - Create an approach, roadmap, or strategy

- "Research" - Gather information or understand something

- "Refine" - Improve an existing research or plan output

After selection, ask: "Describe what you want to accomplish" (they select "Other" to provide free text).

IF context was provided:

→ Check if purpose is inferable from keywords:

- implement, build, create, fix, add, refactor → Do

- plan, roadmap, approach, strategy, decide, phases → Plan

- research, understand, learn, gather, analyze, explore → Research

- refine, improve, deepen, expand, iterate, update → Refine

→ If unclear, ask the Purpose question above as first contextual question

→ If clear, proceed to adaptive_analysis with inferred purpose

Extract and infer:

• Purpose: Do, Plan, Research, or Refine
• Topic identifier: Kebab-case identifier for file naming (e.g., auth, stripe-payments)
• Complexity: Simple vs complex (affects prompt depth)
• Prompt structure: Single vs multiple prompts
• Target (Refine only): Which existing output to improve

If topic identifier not obvious, ask:

• header: "Topic"
• question: "What topic/feature is this for? (used for file naming)"
• Let user provide via "Other" option
• Enforce kebab-case (convert spaces/underscores to hyphens)

For Refine purpose, also identify target output from .prompts/*/ to improve.

Scan .prompts// for existing -research.md and *-plan.md files.

If found:

1. List them: "Found existing files: auth-research.md (in 001-auth-research/), stripe-plan.md (in 005-stripe-plan/)"
2. Use AskUserQuestion:

- header: "Reference"

- question: "Should this prompt reference any existing research or plans?"

- options: List found files + "None"

- multiSelect: true

Match by topic keyword when possible (e.g., "auth plan" → suggest auth-research.md).

Generate 2-4 questions using AskUserQuestion based on purpose and gaps.

Load questions from: [references/question-bank.md](references/question-bank.md)

Route by purpose:

• Do → artifact type, scope, approach
• Plan → plan purpose, format, constraints
• Research → depth, sources, output format
• Refine → target selection, feedback, preservation

After receiving answers, present decision gate using AskUserQuestion:

• header: "Ready"
• question: "Ready to create the prompt?"
• options:

- "Proceed" - Create the prompt with current context

- "Ask more questions" - I have more details to clarify

- "Let me add context" - I want to provide additional information

Loop until "Proceed" selected.

After "Proceed" selected, state confirmation:

"Creating a {purpose} prompt for: {topic}

Folder: .prompts/{number}-{topic}-{purpose}/

References: {list any chained files}"

Then proceed to generation.

Load purpose-specific patterns:

• Do: [references/do-patterns.md](references/do-patterns.md)
• Plan: [references/plan-patterns.md](references/plan-patterns.md)
• Research: [references/research-patterns.md](references/research-patterns.md)
• Refine: [references/refine-patterns.md](references/refine-patterns.md)

Load intelligence rules: [references/intelligence-rules.md](references/intelligence-rules.md)

All generated prompts include:

1. Objective: What to accomplish, why it matters
2. Context: Referenced files (@), dynamic context (!)
3. Requirements: Specific instructions for the task
4. Output specification: Where to save, what structure
5. Metadata requirements: For research/plan outputs, specify XML metadata structure
6. SUMMARY.md requirement: All prompts must create a SUMMARY.md file
7. Success criteria: How to know it worked

For Research and Plan prompts, output must include:

• - How confident in findings
• - What's needed to proceed
• - What remains uncertain
• - What was assumed

All prompts must create SUMMARY.md with:

• One-liner - Substantive description of outcome
• Version - v1 or iteration info
• Key Findings - Actionable takeaways
• Files Created - (Do prompts only)
• Decisions Needed - What requires user input
• Blockers - External impediments
• Next Step - Concrete forward action

1. Create folder: .prompts/{number}-{topic}-{purpose}/
2. Create completed/ subfolder
3. Write prompt to: .prompts/{number}-{topic}-{purpose}/{number}-{topic}-{purpose}.md
4. Prompt instructs output to: .prompts/{number}-{topic}-{purpose}/{topic}-{purpose}.md

After saving prompt(s), present inline (not AskUserQuestion):

```

Prompt created: .prompts/{number}-{topic}-{purpose}/{number}-{topic}-{purpose}.md

What's next?

1. Run prompt now
2. Review/edit prompt first
3. Save for later
4. Other

Choose (1-4): _

```

```

Prompts created:

• .prompts/001-auth-research/001-auth-research.md
• .prompts/002-auth-plan/002-auth-plan.md
• .prompts/003-auth-implement/003-auth-implement.md

Detected execution order: Sequential (002 references 001 output, 003 references 002 output)

What's next?

1. Run all prompts (sequential)
2. Review/edit prompts first
3. Save for later
4. Other

Choose (1-4): _

```

Straightforward execution of one prompt.

1. Read prompt file contents
2. Spawn Task agent with subagent_type="general-purpose"
3. Include in task prompt:

- The complete prompt contents

- Output location: .prompts/{number}-{topic}-{purpose}/{topic}-{purpose}.md

1. Wait for completion
2. Validate output (see validation section)
3. Archive prompt to completed/ subfolder
4. Report results with next-step options

For chained prompts where each depends on previous output.

1. Build execution queue from dependency order
2. For each prompt in queue:

a. Read prompt file

b. Spawn Task agent

c. Wait for completion

d. Validate output

e. If validation fails → stop, report failure, offer recovery options

f. If success → archive prompt, continue to next

1. Report consolidated results

Show progress during execution:

```

Executing 1/3: 001-auth-research... ✓

Executing 2/3: 002-auth-plan... ✓

Executing 3/3: 003-auth-implement... (running)

```

For independent prompts with no dependencies.

1. Read all prompt files
2. CRITICAL: Spawn ALL Task agents in a SINGLE message

- This is required for true parallel execution

- Each task includes its output location

1. Wait for all to complete
2. Validate all outputs
3. Archive all prompts
4. Report consolidated results (successes and failures)

Unlike sequential, parallel continues even if some fail:

• Collect all results
• Archive successful prompts
• Report failures with details
• Offer to retry failed prompts

For complex DAGs (e.g., two parallel research → one plan).

1. Analyze dependency graph from @ references
2. Group into execution layers:

- Layer 1: No dependencies (run parallel)

- Layer 2: Depends only on layer 1 (run after layer 1 completes)

- Layer 3: Depends on layer 2, etc.

1. Execute each layer:

- Parallel within layer

- Sequential between layers

1. Stop if any dependency fails (downstream prompts can't run)

```

Layer 1 (parallel): 001-api-research, 002-db-research

Layer 2 (after layer 1): 003-architecture-plan

Layer 3 (after layer 2): 004-implement

```

Scan prompt contents for @ references to determine dependencies:

1. Parse each prompt for @.prompts/{number}-{topic}/ patterns
2. Build dependency graph
3. Detect cycles (error if found)
4. Determine execution order

If no explicit @ references found, infer from purpose:

• Research prompts: No dependencies (can parallel)
• Plan prompts: Depend on same-topic research
• Do prompts: Depend on same-topic plan

Override with explicit references when present.

If a prompt references output that doesn't exist:

1. Check if it's another prompt in this session (will be created)
2. Check if it exists in .prompts/*/ (already completed)
3. If truly missing:

- Warn user: "002-auth-plan references auth-research.md which doesn't exist"

- Offer: Create the missing research prompt first? / Continue anyway? / Cancel?

After each prompt completes, verify success:

1. File exists: Check output file was created
2. Not empty: File has content (> 100 chars)
3. Metadata present (for research/plan): Check for required XML tags

-

-

-

-

1. SUMMARY.md exists: Check SUMMARY.md was created
2. SUMMARY.md complete: Has required sections (Key Findings, Decisions Needed, Blockers, Next Step)
3. One-liner is substantive: Not generic like "Research completed"

If validation fails:

• Report what's missing
• Offer options:

- Retry the prompt

- Continue anyway (for non-critical issues)

- Stop and investigate

Stop the chain immediately:

```

✗ Failed at 2/3: 002-auth-plan

Completed:

• 001-auth-research ✓ (archived)

Failed:

• 002-auth-plan: Output file not created

Not started:

• 003-auth-implement

What's next?

1. Retry 002-auth-plan
2. View error details
3. Stop here (keep completed work)
4. Other

```

Continue others, report all results:

```

Parallel execution completed with errors:

✓ 001-api-research (archived)

✗ 002-db-research: Validation failed - missing tag

✓ 003-ui-research (archived)

What's next?

1. Retry failed prompt (002)
2. View error details
3. Continue without 002
4. Other

```

• Sequential: Archive each prompt immediately after successful completion

- Provides clear state if execution stops mid-chain

• Parallel: Archive all at end after collecting results

- Keeps prompts available for potential retry

Move prompt file to completed subfolder:

```bash

mv .prompts/{number}-{topic}-{purpose}/{number}-{topic}-{purpose}.md \

.prompts/{number}-{topic}-{purpose}/completed/

```

Output file stays in place (not moved).

```

✓ Executed: 001-auth-research

✓ Created: .prompts/001-auth-research/SUMMARY.md

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

# Auth Research Summary

JWT with jose library and httpOnly cookies recommended