Module 1 — Advanced Prompting & Reusable Prompt Systems
Estimated time: ~90 minutes · Lessons: 5 · Lesson 1.1 is a free preview.
Learning objectives
By the end of this module you will be able to:
- Use advanced prompting techniques (examples, step-by-step reasoning, roles, output contracts).
- Build structured, reusable "prompt templates" with variables.
- Control output format reliably (so the result is predictable every time).
- Create a shareable prompt library a team could use.
No-code module — everything here is plain prompting in any AI assistant.
Lesson 1.1 — Beyond R-C-T-F: four techniques that level you up (preview)
In Course 1 you learned R-C-T-F (Role, Context, Task, Format). That's your foundation. Here are four advanced techniques that reliably improve hard tasks:
1. Few-shot prompting (show examples). Instead of describing what you want, show 2–3 examples of input → output. The model copies the pattern.
Turn product features into benefits. Examples:
Feature: "500ml bottle" → Benefit: "Stays hydrated all morning without refilling."
Feature: "USB-C charging" → Benefit: "One cable for all your devices."
Now do these: [your features]
2. Step-by-step reasoning ("think it through"). For analysis, planning, or anything with logic, ask it to reason before answering. It reduces careless mistakes.
Work through this step by step before giving your final answer: [problem].
3. Assign a strong, specific role. Vague roles give vague output. Be precise and senior.
❌ "Act as a marketer" → ✅ "Act as a direct-response copywriter who has launched 50 e-commerce products and writes plainly, never using hype."
4. Set an "output contract." Tell it exactly what the answer must look like, and what it must not do.
Output rules: respond ONLY with a markdown table (columns: Task, Owner, Due). No intro, no closing text. If information is missing, write "TBD".
These four — examples, reasoning, precise role, output contract — are the difference between hobby prompting and professional results. You'll combine them constantly from here on.
Lesson 1.2 — Structured prompt templates with variables
A professional prompt is a template with variables — named blanks you swap in. This makes prompts reliable, testable, and reusable by anyone.
Anatomy of a strong template:
ROLE: You are {role}.
CONTEXT: {context about the business/situation}.
INPUT: {the_data}
TASK: {what to do with the input}.
RULES:
- {constraint 1}
- {constraint 2}
OUTPUT FORMAT: {exact structure}.
If anything is missing or unclear, ask before proceeding.
Worked example — a "meeting notes → actions" template:
ROLE: You are an executive assistant who writes crisp, accurate summaries.
CONTEXT: Internal team meeting for a small home-care agency.
INPUT: {raw_notes}
TASK: Extract decisions and action items from the notes.
RULES:
- Only use information in the notes. Do not invent.
- Every action needs an owner; if none is stated, mark "Owner: TBD".
OUTPUT FORMAT:
### Decisions
- ...
### Actions
| Action | Owner | Due |
|---|---|---|
Naming the variables ({raw_notes}, {role}) makes it obvious what to fill in — and it's exactly how prompts get stored in tools and code later.
Lesson 1.3 — Making output format reliable
The #1 frustration in advanced work: the AI mostly follows your format, then drifts. Fixes that work:
- State the format explicitly and first-and-last. Put the rule at the top and repeat the key constraint at the end (models weight the ending heavily).
- Give a template to fill, not a description. Show the empty structure and say "fill this in exactly."
- Forbid extras. "Respond with the JSON only. No explanations, no markdown fences." (JSON = a simple, structured text format tools can read — think labeled boxes:
{"name": "...", "due": "..."}.) - Handle the unknown. Tell it what to do when data is missing ("write TBD") so it doesn't invent or break format.
- Ask it to self-check. "Before responding, verify your output matches the format exactly."
Example — forcing clean, machine-readable output:
Return ONLY valid JSON in this shape, nothing else:
{"summary": "", "action_items": [{"task": "", "owner": "", "due": ""}]}
If a field is unknown, use "TBD". Do not add any text outside the JSON.
Reliable format is what lets you plug AI into other tools later (Modules 5 & 8).
Lesson 1.4 — Prompt libraries for teams
A single person reuses templates in a doc. A team needs a shared, versioned prompt library so everyone gets consistent results.
Structure a team prompt library:
- Name & purpose — "Invoice reminder email — chase overdue payments politely."
- The template — with
{variables}. - Example input/output — so people see what good looks like.
- Owner & last updated — who maintains it, when it changed.
- Notes — gotchas, what to verify, privacy rules.
Where to keep it: a shared doc, a Notion/wiki page, or your AI tool's "saved prompts"/"Projects" feature. The key is one source of truth, so a prompt that got refined to excellence is reused by everyone — not reinvented badly each time.
Version your best prompts. When you improve one, note what changed and why. Over time your library becomes genuine company IP — the encoded know-how of how your business uses AI well.
Lesson 1.5 — Prompt patterns worth memorizing
A few reusable "shapes" that solve common advanced needs:
- The Interviewer:
Before answering, ask me up to 5 questions you need to do this well.→ gets missing context automatically. - The Critic:
Give your answer, then critique it and give an improved version.→ built-in quality pass. - The Rewriter-to-spec:
Rewrite the following so it meets these rules exactly: [rules]. Output only the rewrite. - The Extractor:
From this text, extract [fields] as a table/JSON. Use TBD for missing. - The Router:
Classify this message as one of: [categories]. Reply with only the category.→ the seed of automation (Module 5). - The Planner:
Break this goal into a numbered plan with milestones and the first 3 actions.
Keep these as mental tools. Most advanced workflows are just these patterns, chained (Module 2).
🎬 Instructor demonstration script
- Few-shot vs. zero-shot: ask for feature→benefit with no examples (bland), then with 2 examples (sharp). "Show, don't tell — at a pro level."
- Build a variable template live (meeting notes → actions). Fill
{raw_notes}with messy text; show the clean, consistent output. - Force format: demand JSON-only output; deliberately leave a field unknown; show it writing "TBD" instead of inventing. "This reliability is what lets AI plug into other software."
- Show the Critic pattern: answer → self-critique → improved version. "A free quality pass."
- Sketch a team library entry (name, template, example, owner). "This is how AI know-how becomes company IP."
✍️ Copy-and-paste practice prompts
Here are 3 examples of the style I want: [ex1][ex2][ex3]. Now produce the same for: [new input].
Work through this step by step, then give a final answer in this exact format: [format]. Problem: [x].
ROLE: {role}. CONTEXT: {context}. INPUT: {data}. TASK: {task}. RULES: {rules}. OUTPUT FORMAT: {format}. If anything is missing, ask first.
Return ONLY valid JSON: {"...": ""}. Use "TBD" for unknowns. No text outside the JSON.
🛠️ Hands-on exercise (30 min)
- Take a task you do often and rebuild it as a variable template (ROLE/CONTEXT/INPUT/TASK/RULES/OUTPUT FORMAT).
- Add two examples (few-shot) and run it — compare to the no-example version.
- Force a strict output format (a table or JSON) and test it with a case that has missing info — confirm it writes "TBD" rather than inventing.
- Apply the Critic pattern to improve one output.
- Write one library entry for your best template (name, template, example, owner, notes).
You're done when you have one reliable variable-template with examples, strict format, and a library entry.
✅ Quiz (with answers & explanations)
Q1. "Few-shot prompting" means… A) Prompting quickly B) Giving the model a few examples of input→output to copy the pattern C) Using few words D) Asking few questions Answer: B. Showing examples teaches the pattern better than describing it.
Q2. The best way to get reliable output format is to… A) Hope it follows instructions B) Give an exact template to fill, forbid extras, and say what to do for missing data C) Ask in all caps D) Use a longer role Answer: B. Explicit template + "no extras" + a rule for unknowns = reliability.
Q3. An "output contract" is… A) A legal document B) Explicit rules for exactly what the answer must (and must not) contain C) A paid plan D) A type of model Answer: B. You're contracting the shape of the output.
Q4. A team prompt library's main benefit is… A) It looks professional B) Consistent, reusable, improvable prompts so nobody reinvents them badly C) It replaces staff D) It's free marketing Answer: B. One source of truth; encoded know-how.
Q5. True or false: Telling the model what to do when information is missing ("write TBD") helps prevent it from inventing data. Answer: True. Giving it a safe fallback reduces hallucination and format breakage.
📋 Checklist — "Pro prompt"
- Specific, senior role
- Clear context + labeled input
- Examples (few-shot) where format matters
- Explicit output format / contract, repeated at the end
- A rule for missing/unknown data ("TBD")
- Saved as a reusable template with an example
Summary & next steps
You've moved past basic prompting into professional technique: few-shot examples, step-by-step reasoning, precise roles, strict output contracts, variable templates, reliable formatting, and shared prompt libraries. These are the building blocks for everything else in this course.
Next: Module 2 — chaining these prompts into robust multi-step workflows that handle real, messy tasks end to end.