D4 · Prompting and Instructions

This is the heaviest domain on the track – 20% of the mock, roughly 12 of 60 items. It tests whether you can turn a vague request into a prompt that reliably produces what you actually need, and whether you can iterate toward a good result instead of accepting a mediocre first draft. Prompting is the highest-leverage skill in the whole Foundations pathway: everything else assumes you can express intent clearly.

What you need to know

A strong prompt supplies the model with what it cannot guess: who it should act as, exactly what to do, the relevant context, the constraints, the output format, examples where helpful, and how you will judge success. Vague prompts get generic answers because the model fills the gaps with the most probable defaults. Prompting is iterative: you write, read the output against your success criteria, diagnose the gap, and refine one thing at a time. Decomposing a big task into steps beats one giant mega-prompt.

Learning objectives

By the end of this page you should be able to:

1. Name and apply the seven parts of a prompt anatomy.
2. Rewrite a weak prompt into a strong one and predict why the output improves.
3. Run a disciplined iteration loop to close the gap between output and intent.
4. Decide when to decompose a task instead of writing one mega-prompt.
5. Use examples (few-shot) and format specifications effectively.
6. State explicit success criteria so you can tell whether an output is good.

4.1 The anatomy of a prompt

A complete prompt has up to seven components. Not every task needs all seven, but naming them gives you a checklist for what might be missing when an output disappoints.

ROLE ─► TASK ─► CONTEXT ─► CONSTRAINTS ─► FORMAT ─► EXAMPLES ─► SUCCESS CRITERIA
 who     what     why/for      limits       shape     samples      done means…

4.2 Before and after

The fastest way to internalise the anatomy is to watch a weak prompt become a strong one.

Write something about our product launch.

You are our product marketing lead. (role)
Write a LinkedIn post announcing the launch of our scheduling app,
Cadence. (task)
Context: audience is small-business owners who currently juggle
calendars manually; the differentiator is one-click rescheduling. (context)
Constraints: under 120 words, confident but not hyped, no emojis,
one clear call to action. (constraints)
Format: a hook line, two short body lines, a CTA line. (format)
Success: a reader should understand the benefit in the first line
and know exactly what to click. (success criteria)

The difference is not length for its own sake – it is that every gap the model would otherwise fill with a generic default has been supplied.

4.3 The iteration loop

A first output is a starting point, not a verdict. Expert prompting is a loop.

   ┌─────────────────────────────────────────────┐
   ▼                                               │
WRITE prompt ─► READ output against success criteria │
                     │                              │
             gap found? ── yes ─► DIAGNOSE which     │
                     │            anatomy part is    │
                     no           missing/weak ──────┘
                     ▼            then REFINE one thing
                 ship / verify

The discipline that separates good iteration from thrashing: change one variable at a time. If you rewrite the role, tighten the constraints and change the format all at once and the output improves, you have learned nothing about which change helped.

4.4 Decompose instead of mega-prompting

When a task has several distinct steps, splitting it into a short sequence beats cramming everything into one enormous prompt. Each step is easier to steer, easier to check, and easier to fix.

MEGA-PROMPT (fragile)          DECOMPOSED (robust)
"Research the market,          1. "Summarise these three reports."
 write a strategy, draft   ─►  2. "From that summary, propose three strategies."
 the deck, and a press         3. "Draft a deck outline for the chosen strategy."
 release, all at once."        4. "Write the press release from the deck."

Decomposition also lets you verify at each boundary (a review point), which is the bridge into the Applied AI Foundations track. A single mega-prompt hides where it went wrong; a sequence shows you.

4.5 Examples and format specifications

Examples (few-shot) anchor the model to a pattern faster than any description. If you want a specific structure, tone, or labelling scheme, one good example is worth a paragraph of instruction.

Format specifications tell the model the exact shape you need – headings, a table with named columns, a numbered list, JSON with specific fields. Being explicit prevents the model from choosing a shape that is hard to reuse.

4.6 Success criteria and clarity

The most under-used component is the success criterion – the explicit statement of what “done well” means. Without it, neither you nor the model can tell whether the output is good; with it, evaluation becomes a checklist and iteration becomes targeted.

Two clarity habits reinforce it:

• Say what you want, not just what you don’t want. “Write a concise summary a busy executive can read in 30 seconds” beats “don’t be too long”.
• Front-load the most important instruction. Bury the key constraint at the end and it competes with everything else for attention.

weak:   "Make it good and not too technical."
strong: "Success: a non-technical manager understands the recommendation
         and the one risk in under a minute; no jargon; one page."

Decision framework

Use the RTCCFES checklist (Role · Task · Context · Constraints · Format · Examples · Success) to build or repair any prompt. Walk the columns; a disappointing output almost always traces to a blank cell.

The value: it converts “the output isn’t great” into “context and success criteria are missing”, which is an action rather than a complaint.

Common mistakes

Scenario challenge

Scenario. Sam needs a customer-facing release-notes post for a new feature. He types “write release notes for our new export feature” and gets a bland, overlong paragraph that mixes internal jargon with marketing fluff and buries the actual change. He re-sends the same prompt three times, getting three equally mediocre variants, then complains that “the AI just isn’t good at this”.

Expert reasoning trace.

1. Diagnose against the anatomy, not the model. The prompt has a task but no role, no audience context, no constraints, no format and no success criterion – so the model produced the most probable generic release-notes text. The failure is in the prompt, not the model.
2. Recognise the thrashing. Re-sending the identical prompt three times cannot improve the output because nothing changed; non-determinism gives new wording, not a better structure.
3. Rebuild with the RTCCFES checklist. Role: “you are our product communicator”. Context: audience is existing customers who export data weekly; the change lets them schedule exports. Constraints: under 100 words, plain language, no internal codenames. Format: a one-line headline, a what-changed line, a how-to-use line. Success: a customer knows what is new and how to use it in 20 seconds.
4. Iterate one variable. If the rebuilt output is close but slightly too formal, adjust only the tone constraint next time and compare – so he learns which lever mattered.
5. Consider decomposition if scope grows. If the notes needed to cover five features, he would decompose (one prompt per feature, then a combine step) rather than one sprawling prompt.

Exam-correct outcome: stop re-sending the vague prompt, rebuild it with the missing anatomy components and an explicit success criterion, then iterate one change at a time – recognising the gap was in the instructions, not the model’s ability.

Assessment traps

Practice questions

Key takeaways

• A strong prompt supplies role, task, context, constraints, format, examples and success criteria – the RTCCFES checklist.
• Disappointing output usually maps to a missing anatomy component, not a weak model.
• Iterate deliberately: read against success criteria, then change one variable at a time.
• Decompose multi-step tasks into a checkable sequence instead of one mega-prompt.
• Show a format with an example rather than only describing it.
• State the positive target and an explicit success criterion; front-load the key instruction.
• Re-sending an unchanged prompt varies wording, not structure – refine, don’t repeat.