Meta Prompting: 5 Recipes That Ship (2026)

Quick answer

Meta prompting is using one prompt to write, grade, or repair another prompt. You are prompting about prompting. As of July 2026 it is the cheapest way to turn a vague instruction into one that ships, because the model already knows what a good prompt looks like; you just have to ask it to build one. Below are five paste-ready meta-prompt recipes, each with why it works and where it breaks. Then the honest part: when meta prompting is a waste of tokens.

The pattern works the same on OpenAI and Anthropic models. The technique was formalized in the 2024 paper Meta Prompting for AI Systems, which treats the prompt itself as the thing to optimize.

Recipe 1: Make the model write the prompt

Do not hand-tune wording. Describe the job, ask for the prompt.

You are a prompt engineer. Write a production prompt for this task:

Task: classify a support email as billing, bug, feature, or other.
Constraints: one-word answer, no prose, handle empty input.

Return ONLY the finished prompt, ready to paste. No commentary.

Why it works: the model has read millions of prompts. It defaults to structure you would have forgotten: an output constraint, an edge case, a role line.

Fails when: your task description is thin. Garbage spec in, garbage prompt out. Spend your effort on the spec, not the wording.

Recipe 2: Self-critique, then rewrite

Give the model your draft prompt and ask it to attack its own instructions.

Here is a prompt: {{draft_prompt}}

List the 3 ways this prompt will fail on a real input.
Then rewrite it to fix all 3. Return only the rewritten prompt.

Why it works: critique and generation are different tasks. Splitting them beats "improve this," which just reshuffles adjectives. This is the same move Anthropic ships as its prompt improver, and OpenAI documents as a meta-prompt cookbook.

Fails when: you run it in a loop. Three rounds of self-critique drifts into verbose, over-hedged prompts. One pass. Ship.

Recipe 3: Generate the rubric before the answer

Ask for the grading criteria first. Then answer against them.

Task: {{task}}

Step 1: Write the rubric a strict reviewer would use to grade
an answer to this task. 4 to 6 criteria, each one line.
Step 2: Answer the task. Score yourself against each criterion.
Return the rubric, the answer, and the scores.

Why it works: the rubric forces the model to name what "good" means before it commits. You get a self-graded answer and a reusable eval in one call. Pair it with a structured-output recipe to make the scores machine-readable.

Fails when: the model grades itself generously. Treat the score as a smoke test, not a verdict.

Recipe 4: Have it write your few-shot examples

Few-shot examples are tedious to hand-author. Generate them.

Task: {{task}}
Write 4 few-shot examples for this task. Vary the difficulty.
Include one adversarial or edge case. Format each as
Input: ... / Output: ... exactly. Return only the examples.

Why it works: the model produces diverse, correctly-formatted examples faster than you can type them. Review, delete the weak ones, keep the rest. More on the payoff in few-shot prompting recipes that ship.

Fails when: you ship the examples unread. Generated examples can encode a subtle wrong assumption that then trains every call. Always review.

Recipe 5: Extract a reusable template from one good output

You got a great answer once. Turn it into a parametric prompt.

Here is a task and an answer I liked:
Task: {{task}}   Answer: {{good_answer}}

Reverse-engineer the prompt that would reliably produce answers
like this one. Replace the specifics with {{variables}}.
Return only the templated prompt.

Why it works: it captures a one-off win as a repeatable asset. This is meta prompting run backward: from output to instruction.

Fails when: the good answer was luck. Regenerate twice with the template before you trust it.

When meta prompting wastes tokens

The consensus says always polish your prompt with AI. Wrong.

Skip it when the task is trivial. "Summarize this in two sentences" does not need a meta pass; you just doubled your latency and cost to reword a prompt that was already fine.

Skip it in a hot path. Meta prompting is an authoring-time tool. Do it once, save the output, hardcode the result. Never run a prompt-writing prompt on every user request.

Skip the loop. One meta pass helps. Five compounds noise and burns budget. The returns go flat after the first rewrite.

Meta prompting is a workshop technique. Build the tool, then put the workshop away.

Meta prompting is not a magic wand. It is a fast way to borrow the model's sense of what a good prompt looks like, once, at authoring time. Build the prompt with it. Then get out of the loop.

Cost to test: $0.01 per meta pass on a small model.