Prompt engineering changed, but instructions still matter
Prompt engineering spent three years as one of the most discussed skills in the digital world, and job adverts for it have largely disappeared since. Part of the reason is that newer models produce reasonable results from very simple instructions. You no longer need a secret vocabulary or a page of rules to get something usable back.
That does not mean instructions stopped mattering. Anyone who works with LLMs regularly knows that detailed, well-structured prompts still produce noticeably better output, and that there is a real difference between adding more information and structuring it properly.
The obstacle is knowledge rather than effort. Very few people confidently know which technique fits which situation, and most of us have neither the time nor the need to memorise a library of frameworks and patterns.
There is a practical way around this. You can ask a model to write the instruction for you, then spend your time checking whether the instruction describes the real task. This is usually called meta-prompting, and here is what it looks like in practice, along with the places where it fails.
Weak prompts are usually missing information, not phrasing
A surprising number of people still believe that good results come down to finding a specific form of words. What matters far more is the information the model is given. It needs the relevant pieces, and it needs enough of the wider picture that the right parts of the network are activated in the first place.
Take a request we see constantly: "write a LinkedIn post about my company." The end goal is clear enough, but almost everything that would shape a good post is absent. The model does not know what the company does, who reads its posts, or what this particular post is supposed to achieve. With nothing to narrow the scope, it falls back on the average of everything it has seen, which is why the result is vague, generic and immediately recognisable as AI content.
The fix is to step back, work out what the ideal post would look like, and describe that instead — for example, naming the audience (owners of businesses with fewer than 50 staff, mostly non-technical, sceptical about AI hype), the goal (sign-ups, not general engagement), the tone (plain and specific, with no claims about transformation or revolution), what must be included (the problems the workshop solves, and the date), what to avoid (unsourced statistics, or any suggestion that AI replaces staff), and a length limit.
The second version is not better written, it is better informed. Audience, goal, tone, required content, forbidden content and length are all now decided by you rather than guessed by the model.
Working through this properly has an obvious cost. It takes longer than you want it to, and it is easy to leave out one of the parts and quietly lower the quality of everything that follows. When the task is one you repeat weekly, that cost repeats with it.
What meta-prompting is
A meta-prompt is a set of instructions that gives a model the scaffolding to create, analyse, modify or improve other prompts. Rather than asking the model to do the task, you ask it to help you design the instruction that will do the task later.
Research supports the idea that models are good at this. The paper Large Language Models Are Human-Level Prompt Engineers found that automatically generated instructions can match or beat human-written ones, which is what makes the approach worth the extra step.
One caveat on the name. The term is not fully standardised, and some researchers use "meta-prompting" for high-level orchestration between models rather than for generating or improving instructions. We are using it in the narrower, practical sense throughout.
A workable meta-prompt can be short: tell the model it is an experienced prompt engineer, name the recurring task — writing LinkedIn posts announcing workshops — and instruct it to ask questions, covering at least the objective, the audience, the tone, the required and forbidden content, the structure, and what a bad result would look like, before writing anything, in one numbered batch, and only to write the prompt once you have answered, stating at the top which prompting techniques it used and why.
Two details in there are doing most of the work. Holding the model back from writing immediately is what turns this into an interview rather than a guess, and asking it to name its techniques gives you something to check when the resulting prompt underperforms.
This does not remove the thinking, it relocates it. The meta-prompt can only structure the information you give it, so a confident answer that misdescribes your audience produces a confident prompt aimed at the wrong people.
The interview is where the work happens
A good meta-prompt does not return a new prompt straight away. It comes back with questions: what is the objective, who will use the result, what inputs are available, what constraints apply, what does failure look like, and can you provide examples of good and bad output.
These questions do real work, and not only because they collect facts. They force you to answer things you would otherwise leave implicit. Most people cannot immediately say what a bad version of their own routine task looks like, and the answer usually turns out to be the most useful line in the finished prompt.
Your answers also drive the technique selection. The model knows the common approaches and picks between them based on what you said: few-shot prompting where you supplied examples, decomposition where the job is too large for one step, structured output where the result feeds into something else, a verification step where the model should check its own work before presenting it. You do not need to know these techniques in advance, which is rather the point.
The limitation is that the model can only ask about what it can imagine. It will reliably ask about audience and tone, and it will not ask whether your legal team has to approve every post before it goes out. Constraints that are obvious inside your company are invisible from outside it, and they are worth adding unprompted.
Six things a meta-prompt can do
In day-to-day work, meta-prompting tends to show up in a handful of forms: generation, turning a short description of a task into a complete instruction; improvement, rewriting an existing prompt to make it clearer and more reliable; diagnosis, working out why an instruction keeps producing weak or inconsistent output; adaptation, taking something that works for one use case, such as LinkedIn posts, and adjusting it for another, such as newsletters or sales emails; evaluation, comparing several variants against defined criteria; and optimisation, generating and testing alternatives, often repeatedly.
The first four are worth doing by hand in a chat window. Evaluation and optimisation pay off mainly inside automated workflows, where a small improvement to a prompt that runs a thousand times a day compounds into something that justifies the setup cost. Running an optimisation loop over a prompt you use twice a month is unlikely to repay the effort.
The job changes from wording to specification
Once your meta-prompt exists and you start generating instructions with it, your role changes. You are no longer writing prompts, you are specifying and evaluating them.
Finding the right words stops being your job, because models handle wording at least as well as you do and probably better. What remains yours is the ingredients: intent, context, constraints, inputs, examples and a working definition of what good looks like. The model can structure all of that competently. Only you can judge whether the resulting prompt describes the task you actually have.
This shift has a cost worth naming. Reviewing a prompt someone else wrote is harder than reviewing one you wrote yourself, because you have no memory of the decisions behind it. A generated prompt can read as authoritative while quietly encoding an assumption you never made, so it needs reading as a draft rather than a deliverable.
Where meta-prompting falls short
There are several failure modes, and they are easy to miss precisely because the output looks polished.
Prompts that look professional and do not work: a model will happily produce a well-organised instruction with clear sections and confident constraints that performs no better than what you started with. Test every generated prompt against realistic inputs and judge it by the output, never by how sophisticated it reads.
The blind spot problem: when the same model generates, analyses and evaluates a prompt, weaknesses in its training data or weights can pass through all three stages unnoticed, because the thing doing the checking shares the flaw. For anything important, run the same meta-prompt through a different model and compare the outputs.
Self-critical is not self-correcting: a model can accurately identify a weakness in a prompt and then fail to fix it in the revision, or fix it while introducing a new one elsewhere. Its suggestions are informed recommendations rather than final decisions, and the revision needs the same test as the original.
Length works against you: more complexity does not automatically produce better results. Beyond a certain point, extra rules and examples compete for the model's attention and dilute the instructions that mattered, as well as consuming context that the actual task needs. Every section of a prompt should earn its place, and the shorter version sometimes wins.
Prompts are model- and context-dependent: something that works well on one model can behave differently on another, or on a newer version of the same one, because the behaviour you tuned against was never a specification. Test across scenarios and edge cases, and across models where the stakes justify it.
Choosing how much structure to add
These modes combine, and the useful sequence is usually generation first, then diagnosis when the output disappoints, then adaptation once the prompt is working and you want it somewhere else. Improvement sits alongside all three.
There is no reason to reach for a meta-prompt every time you open a chat window. Start with the direct request. If the answer is good enough, you are finished, and the ten minutes you would have spent on an interview stay in your pocket. Meta-prompting earns its keep when the task repeats, when the result feeds into something automated, or when you have already rewritten the same instruction three times without getting a stable result. A one-off question does not need a designed prompt.
The same restraint applies inside the generated prompt itself. If the meta-prompt returns two pages of scaffolding for a task that a paragraph would cover, that is a signal to push back rather than a sign of thoroughness.
A meta-prompt is only part of the workflow
A well-designed prompt improves the chance of a useful answer. It does not guarantee one, because the models remain nondeterministic and the same instruction can produce different output on different runs.
When a prompt supports a real business process, it should sit alongside a small set of test inputs where you already know what a good answer looks like; version control, so you can tell which prompt produced which output; re-testing after a model upgrade, since a provider changing the default model is a change to your system; validation of the output format when another process depends on it; and human review at the point where a mistake would actually cost something.
None of this is specific to meta-prompting. It is the same discipline any component of a working system needs, and a generated prompt is no more exempt from it than a hand-written one.
Final thought
Meta-prompting does not remove careful thinking, it moves that thinking somewhere more useful. Instead of hunting for the right words, you spend your time defining the problem, supplying the context and checking whether the output meets a standard you set in advance.
Take the one instruction you retype most often. Write down what a bad version of that output looks like, feed that to a meta-prompt along with the task, and test whatever comes back against three real inputs where you already know the right answer. If it beats what you were typing before, you have replaced a recurring cost with a one-off one.
The clearest evidence that models can write good instructions comes from the paper that measured it, alongside practical guides from OpenAI , IBM , PromptHub and Anthropic on how to use the technique.
Which part of your workflow would you most like to see turned into a reusable prompt? Let us know whether your processes need automation or you need help implementing AI in your business.