Anatomy of a prompt that works

Why your prompts disappoint (and why it's not the model's fault)

Monday morning, Sofia types: "Write a LinkedIn post about our new product." The result is a mush of generic enthusiasm, full of hollow phrases she could copy-paste onto any company. She concludes that "AI writes badly." The diagnosis is wrong: the model did exactly what it was asked — which was almost nothing specific.

A language model doesn't read your mind. It completes your text with the most likely continuation given what you've provided. If you give it a fuzzy request, the most likely continuation is a fuzzy, average, consensus answer — the statistical mean of everything on the Internet that resembles your request. The precision of your request is therefore the number one quality lever, well ahead of the choice of model.

That's the good news of this course: you don't need a better tool, you need a better way of asking. And that way of asking can be learned, structured and reused. Let's start with the basic anatomy.

Context + Task + Format: the three ingredients

A strong prompt answers three questions: who are you and in what situation (context/role), what exactly must you do (precise task), in what form should the result be delivered (output format). Remove any one of the three and the quality visibly drops.

The context frames the universe of the answer: the industry, the audience, the situation, the company's tone. The task defines the expected action with a precise verb: write, summarize, compare, classify, rephrase. The format locks in the delivery: length, structure, tone, what to include and exclude. Together, they turn a lottery into a precise order.

You are an SEO expert. (role)
Write 5 headlines for an article about specialty coffee. (task)
Format: numbered list, each headline < 60 characters, curious tone. (format)

flowchart LR
  C["Context / role"] --> PR["Structured prompt"]
  T["Precise task"] --> PR
  F["Output format"] --> PR
  PR --> Q["Quality output"]
  PR -.->|"One ingredient missing"| G["Generic output"]

Context: giving the model what it can't guess

The model knows the world in general, but it knows nothing about your situation: your company, your audience, this week's constraint, what has already been tried. Everything you don't say, it invents — and it invents it averagely. Context is the part of the prompt where you fill that gap.

For Sofia, good context looks like: "We're a 40-person company selling shift-scheduling software to restaurant owners. Our LinkedIn audience: overwhelmed restaurant managers, not very tech-savvy, sensitive to time saved. Brand tone: direct, concrete, never corporate." Three sentences, and the model already can't produce the same generic mush as before.

Practical rule: ask yourself what a brilliant new colleague who arrived this morning would need to know to do the task. That's exactly what the model needs to know too. No more (no need to tell your life story), no less.

The task: an action verb and a measurable goal

"Tell me about marketing" isn't a task, it's a theme. "Write 3 LinkedIn hooks to sell a marketing course to overwhelmed freelancers" is a task: a verb (write), a quantity (3), a deliverable (hooks), a target (overwhelmed freelancers) and a goal (sell).

Also beware of multiple tasks hidden in a single sentence. "Summarize this report and propose actions and write an email to the team" mixes three deliverables: the model will botch at least one of them. Split it into three requests, or explicitly announce the three expected parts with their respective formats.

The format: the most forgotten ingredient

It's the most frequent omission, and the most costly. Without a format, the model chooses for you: often too long, structured in paragraphs where you wanted a list, with a polite-assistant tone where you wanted punchy. Specifying the format avoids 80% of the back-and-forth corrections.

• Length: "maximum 120 words", "in 5 bullet points", "a single sentence".
• Structure: "numbered list", "3-column table", "headline + 2 paragraphs + call to action".
• Tone: "direct and concrete", "warm without being casual", "neutral and factual".
• Inclusions/exclusions: "no technical jargon", "no exclamation marks", "include one number per bullet".

The vague-prompt trap: a before/after

Let's see the difference on Sofia's real case. Vague version:

Write a LinkedIn post about our new product.

Result: "We are thrilled to announce the launch of our revolutionary new product..." — interchangeable filler, zero information, corporate tone that nobody reads. Now the structured version:

Context: we are a small company selling scheduling software to restaurant owners. LinkedIn audience: overwhelmed restaurant managers, not very tech-savvy. Brand tone: direct, concrete, never corporate.

Task: write a LinkedIn post announcing our new "1-click replacement" feature (find a replacement when a waiter is sick, in 1 click instead of 12 phone calls).

Format: 80-120 words, opening line as a question, 1 quantified benefit, final call to action, no exclamation marks, no hashtags.

Same model, same day, same feature. The second version produces a post that's publishable almost as is. The difference doesn't come from the tool: it comes from the information and guardrails the prompt provides. Precision isn't optional, it's the main lever.

System prompt vs user prompt

In most tools (ChatGPT, Claude, the APIs), there are two levels of instruction. The system prompt (or "custom instructions") defines the permanent behavior: who the assistant is, its tone, its rules. The user prompt is your request of the moment. The system level carries more weight and persists across the whole conversation.

Concretely: if Sofia repeats "direct tone, never corporate, no exclamation marks" in every message, she's wasting time. These permanent rules belong in her tool's system or custom instructions. The user prompt then contains only what changes: today's task and its format. This is also the foundation of custom "GPTs" and configured enterprise assistants.

Structure for clarity (and to prepare what's next)

Visually separate the parts of your prompt: a context block, a task block, a constraints block. Use headings ("Context:", "Task:", "Format:") or delimiters like --- or tags to isolate a text to be processed from the rest of the instructions. The model follows better, and you proofread better.

This discipline has a second benefit, which we'll exploit in chapter 5: a prompt structured in blocks turns into a reusable template in two minutes. A prompt written as one confused stream, on the other hand, will have to be rewritten every time. Structuring today means capitalizing for tomorrow.