Prompt Engineering: the four blocks of a good brief

By Marco Kohns, Co-founder of ENLIX, lecturer in AI and growth

· 14 min read

Prompt engineering is the work of handing a task to an AI model so that the result can be checked. Wording the question is the smallest part of it. What decides the outcome is the context the model cannot know by itself, the limits it should work inside, and an example of what a good result looks like.

That is not an opinion, it can be counted. This article was written by an agent that runs three times a week without supervision. Its brief is versioned in our repository and runs to 555 words. The goal inside it is eleven words. The other 544 are context, limits and examples, and the same run reads a further 7,156 words of standing project rules from two more files.

Below: what Anthropic's own guide recommends, in what order, and which four blocks we use in the course.

What is prompt engineering?

It is work on the input, not on the model. You change nothing about the AI itself, you change what it knows about your task before it starts. That is the whole lever, and it is bigger than it sounds. If the word input itself is still fuzzy, what is a prompt settles that first.

The part called "engineering" is repeatability. A phrasing that happens to produce a good result once is not prompt engineering. It gets interesting where the same input works again tomorrow and in a different project, and where you can tell what went wrong when it does not.

Anthropic's guide names three things it assumes before any of this starts: a clear definition of the success criteria for your use case, some way to test empirically against those criteria, and a first draft prompt you want to improve (Prompt engineering overview). Without the first one, every phrasing decision is a matter of taste, because nobody can say whether it helped.

That also explains why so many guides leave you exactly where you were. They list techniques, and none of them works while it is still open what a good result would look like.

Why is the wording the smallest part?

Because the model does not read only your question. It reads everything in the context, and in a seriously built workflow the question is a fraction of that. We counted it on this article.

What the model reads for this article, in words

The goal11Rest of the brief544Project context (CLAUDE.md)3836Editorial rules (seo/ROADMAP.md)3320

Counted on 7 October 2026 in `enlixai/enlix-academy`. The goal is the first sentence of the brief: “Write and publish today's ENLIX Academy blog post, German and English.” Not included: the skill, and the articles the run then opens for itself.

What the model reads for this article, in words
The goal11
Rest of the brief544
Project context (CLAUDE.md)3836
Editorial rules (seo/ROADMAP.md)3320

Eleven words out of 7,711 are the actual request. Everything else is preparation, written once and carried along on every run since, the largest block of it this project's rule file: how the brand sounds, which figures are sourced, which claims are forbidden, where a file belongs.

From which comes the practical rule that carries the rest of this article: when a result is wrong, the phrasing is rarely the reason and missing context or a missing limit almost always is. The question is then not "how do I ask better" but "what does the model not know that I know".

The same holds at small scale, without any agent. Type "write me a newsletter" into a chat window and you have given a goal and nothing else. The model then invents the audience, the occasion, the length and the tone, and each of those inventions is a place where the result goes past you.

What does Anthropic's own guide recommend?

Clarity first, then context, then examples, then structure, and the role only after that. The order is written that way in the reference for current Claude models, and it contradicts what most guides start with.

OrderPrincipleThe sentence that matters
1Be clear and direct"If you want above and beyond behavior, explicitly request it"
2Add context to improve performance"Providing context or motivation behind your instructions"
3Use examples effectively"Include 3 to 5 examples for best results"
4Structure prompts with XML tagsInstructions, context, examples and inputs each in their own tag
5Give Claude a role"Even a single sentence makes a difference"
The general principles from Anthropic's reference, in the order the page gives them.Source: platform.claude.com, Prompting best practices

The role comes fifth. In most popular guides "You are an experienced tax advisor" is the very first tip, and it is not wrong, it is just the smallest of the five. A model that knows the role but not the task will reliably miss the point in the right tone.

The comparison on the same page explains why: think of the model as a brilliant but new employee who lacks context on your norms and workflows. You do not hand a new employee a job title on day one either, you hand them the task and the house rules.

Next to it sits a check that takes two minutes and that we think is the best part of the whole guide. Anthropic calls it the golden rule: show your prompt to a colleague with minimal context on the task and ask them to follow it. If they would be confused, the model will be too.

Why does a ban without a reason work less well?

Because the model can generalise from a reason and cannot generalise from a bare prohibition. Anthropic shows this with an example of two lines that explains more than most lists of techniques.

The less effective version:

NEVER use ellipses

The more effective one:

Your response will be read aloud by a text-to-speech engine, so never use ellipses
since the text-to-speech engine will not know how to pronounce them.

Both forbid the same thing. The second says what the output is for, and Anthropic adds one sentence that holds the whole mechanism: "Claude is smart enough to generalize from the explanation."

That is the difference between a rule and a reason. With the reason the model also handles the cases the ban does not mention: bracketed omissions, symbols, abbreviations that sound strange read aloud. Without it, it keeps exactly one rule and falls back on the next variant.

For your own work that means every limit carries its reason. "No tables" becomes "no tables, the text ships in a newsletter without CSS". That costs eight words and saves the round in which you argue the table back out.

How many examples belong in a prompt?

Three to five, and they should differ from each other. Anthropic calls examples "one of the most reliable ways" to steer output format, tone and structure, and makes three demands of them.

  • Relevant. They mirror your actual use case, not a simplified version of it.
  • Diverse. They cover edge cases and vary enough that the model does not pick up unintended patterns.
  • Structured. They sit in <example> tags, several of them in <examples>, so they are distinguishable from the instructions.

The second point is where most prompts fail. Give three examples that resemble each other and you get back a model that mistakes the resemblance for the task. Three examples from the same month, the same industry or with the same sentence length are, in effect, one example.

A single example still has its place, in the spot where you are not steering but pinning down an expectation. Our course brief carries exactly one, a worked case with the result it should produce. It does not tell the model how to write, it tells the model how to know it is finished.

Where in the prompt does what go?

Long data at the top, your question at the bottom. This applies from roughly 20,000 tokens of input and it is the only positional rule in the guide that comes with a number.

Anthropic writes: "Place your long documents and inputs near the top of your prompt, above your query, instructions, and examples", and adds that queries at the end can improve response quality by up to 30 percent in tests, especially with complex, multidocument inputs.

The figure is Anthropic's own and comes from tests that are not public, so take it as a direction rather than a measurement for your case. The direction itself is cheap to follow: the contract first, then the question about the contract. The transcript first, then the request for a summary.

With several documents, structure comes on top. Each document in a <document> tag, with <source> for its origin, so the model can keep apart which statement came from which file in its answer. Without that separation you get the kind of summary that is correct but no longer traceable.

What does a complete brief look like?

Four blocks: goal, context, limits, example. That is the shape we build with live in the course, and it arranges the principles above so that you notice, while writing, which part is missing.

The live-build brief, words per block

Goal25Context57Limits62Example35

196 words in total, 17 of them for title, meta description and FAQ. Counted on 7 October 2026 in `webinar/LIVE-BUILD.md`. The brief builds a public price calculator in six minutes.

The live-build brief, words per block
Goal25
Context57
Limits62
Example35

The goal is the shortest block, and that is not an accident. A goal that grows longer is usually context in disguise. It belongs in one sentence describing a result someone could check: not "make a page better" but "a public page where a visitor answers five questions and gets an indicative price".

The context is everything the model cannot read for itself. In the live build that is the example business's price list and the state of the project. With Claude Code this block gets shorter, because the tool opens the project files itself, and that shift is exactly why the work migrates out of the chat window and into files.

The limits are the longest block, and the expensive things live in them: no database, no sign-in, the email address only on submit, a data-protection checkbox, mobile first. Each of those lines prevents a round in which something gets built and then removed again.

The example is the block that goes missing most often. It is not a sample text but a worked case with the expected result, against which the model can measure its own answer. If you want to fill the four blocks in for your own task without sorting them by hand, use our prompt generator: it puts your own words into the shape, without asking an AI anything. How far the same four blocks carry without any coding knowledge is in what is vibe coding.

What changes when an agent carries out the brief?

The prompt gets shorter and the standing context gets bigger. As soon as a tool reads files and runs commands, it answers half the context block itself, and in exchange the question of where the rules live permanently becomes the important one.

The same task, once as a question and once as a brief

Step that costs you time

One line in a chat

  1. You type the request
  2. Model guesses audience and scope
  3. Result arrives
  4. You read it and correct
  5. You describe what was missing
  6. Second result
  7. You correct again

3 of 7 steps need you

Four blocks

  1. You write goal, context, limits, example
  2. Model works inside the frame you set
  3. Result arrives
  4. You check it against your example

1 of 4 steps need you

The sequence as we show it in the course. Not a measurement but the mechanism: every correction round is a piece of context that was missing beforehand.

So the work does not disappear, it moves. What used to be retyped into every prompt sits, for us, in a project file that every run reads, and that is the reason for the 3,836 words in the first chart. Where the line runs between a project rule and a separate, versioned working instruction is in Claude Code skills.

On top of that come phrasings you do not need without an agent. Anthropic documents separate text blocks for agentic work against typical overshoots, among them overeagerness: do not add features that were not asked for, do not write comments into code you did not change, do not build error handling for cases that cannot occur. Those are limits, not phrasings, which is why they sit once in a file rather than in every prompt.

What an agent needs beyond that, a goal, tools and a stop condition, is in what is an AI agent, and where those tools come from is in Claude Code MCP.

How do you notice that a prompt has got worse?

You do not, as long as you check nothing. That is the uncomfortable part of the subject: a prompt does not degrade visibly, it keeps producing a result, only a worse one, and without a check somebody notices weeks later.

This is exactly why the prerequisite of being able to test empirically against success criteria sits ahead of the first technique in Anthropic's guide. In a chat window that check is your own judgement, and it is enough as long as you read every result. The moment something runs unsupervised, it is not.

With the agent that writes this article, the checks are therefore part of the brief rather than part of the phrasing. Three of them can stop the run before anything is published: the project's test suite, a production build in which every marketing page has to stay static, and a search for the words that are banned here. If one of them fires, no article appears, only a report of what it was.

For a prompt in a chat window the small version of this is one extra sentence in the brief: how you will recognise that the result is usable. That is the same example block from above, read from the other direction. A brief without that sentence is not wrong, it is just not checkable, and so it cannot be improved either.

What does prompt engineering not solve?

Not every problem is a prompt problem, and Anthropic says so in its own guide more plainly than most vendors would: "Not every success criteria or failing eval is best solved by prompt engineering." Latency and cost, for instance, often shift more easily through the choice of model.

Three cases where better phrasing changes nothing:

  • The information is missing. If the number you want an answer about is nowhere in reach, no phrasing will fetch it. What you need then is a source in the context, not a better sentence.
  • There is no success criterion. Without an idea of how a good result is recognised, a prompt cannot be improved, only altered.
  • The task is actually deterministic. If the steps are fixed and always the same, that belongs in a script. A script is cheaper, faster and you can read it.

And one qualification that puts the rest in proportion: the principles above come from Anthropic's reference for current Claude models. The four blocks depend on no vendor, but details such as XML tags and the exact text blocks are measured on Claude. With a different model you check them against your own examples instead of adopting them.

If you introduce this way of working in a team, you can record the training as an AI literacy measure with the AI training record. What Article 4 of the EU AI Act asks for is covered in our article on the AI literacy obligation.

Where the four blocks sit in the sequence, meaning what comes before and after them, is set out in how to learn Claude Code. The smallest case of them, a request carrying a file, a symptom and a definition of done, is shown on a single example in your first session with Claude Code.

If you would rather write the four blocks against your own project until something runs, instead of reading about them: that is the practical half of the Claude Code System.

Frequently asked

What is prompt engineering in simple terms?

The work of handing a task to an AI model so that the result can be checked. Wording the task is part of it, but the larger part is the context the model cannot know by itself, the limits it should work inside, and an example of a good result. Anthropic's guide describes the model as a "brilliant but new employee who lacks context on your norms and workflows".

Do you need to know how to code to do prompt engineering?

No. The four things that carry a brief are subject-matter questions, not technical ones: what should come out, what does the model need to know about your case, what must not happen, and what does a good result look like. It gets technical only once the model writes files and runs commands, and even then the work is setting limits rather than typing code.

What belongs in a good prompt?

A goal someone could check, the context the model cannot read for itself, the limits with their reasons, and an example of the expected result. In the brief we use to build a price calculator live in the course, that is 25 words of goal, 57 of context, 62 of limits and 35 of example. The goal is the shortest of the four blocks.

What is the difference between a prompt and prompt engineering?

A prompt is the single input. Prompt engineering is the work of making that input repeatable: which context travels with it permanently, which limits apply, how a good result is recognised, and how you notice when it gets worse. A prompt is a sentence, prompt engineering is a setup.

Is prompt engineering a job of its own?

The work does not disappear, it moves out of the chat window into versioned files: project rules, examples, stop conditions. Whoever writes prompts today maintains the context an agent works from tomorrow. That is less a craft of phrasing and more operations work, and it sits better inside the role that owns the subject than in a separate post.

Written by

Marco Kohns

Co-founder of ENLIX, lecturer in AI and growth

Marco worked as a growth product manager at a Silicon Valley scale-up and has been teaching that way of working ever since. Today he runs ENLIX with Tobias and builds two products of his own on the same systems, which is what the courses open up.

  • Growth product manager at a Silicon Valley scale-up, Series A to B, backed by a16z, General Catalyst and Sapphire, with users in over 100 countries and more than 20,000 cities
  • Peer-reviewed research in the Journal of Business Research on generative AI in growth, with Prof. René Bohnsack. The research began in summer 2022, months before ChatGPT was public
  • Executive education lecturer at Católica-Lisbon, over 10 seminars, more than 1,500 people taught

Keep reading