Reusable Prompt Templates & Cheat Sheet

Reviewed & published by Brayan K

This is your toolkit. Here are copy-paste templates that bake in everything you learned across the course — being specific, giving a role, showing examples, asking for reasoning, controlling the format, and fact-checking — plus a one-page cheat-sheet you can keep open whenever you use AI.

Part of the free Prompt Engineering course at LearnCodingFast — hands-on lessons with worked examples and the output they print, plus practice exercises and a quick quiz.

Fill in the blanks, delete the lines you don’t need, and send. Over time, these become your own personal prompting cheat-sheet.

What You'll Get in This Lesson

• An all-purpose template you can adapt to anything
• Ready-made templates for writing, coding, and research
• How placeholders <like this> work
• A one-page cheat-sheet of every technique
• How the whole course fits together
• Building your own personal prompt library

1 The all-purpose template

Start here for almost any task. Anything in <angle brackets> is a blank to fill in. Delete lines you don’t need.

Act as <a careful editor / a Python developer / a tutor>.
Task: <one clear sentence describing what you want>.
Context: <anything the AI needs to know>.
Format: <table / bullets / JSON / one paragraph>.
Constraints: <length, tone, what to avoid>.
If the problem is multi-step, think step by step.
If you're unsure of a fact, say so instead of guessing.

2 Ready-made templates

Rewrite the text below to be <clearer / more formal /
friendlier>. Keep it under <100> words and keep the
key points. Audience: <who will read it>.
Text: <paste your text>

Language + version: <e.g. Python 3.11>.
Goal: <what the code should do>.
<If fixing a bug, paste the snippet + full error + line.>
Constraints: <no new libraries / handle empty input>.
Write the code, comment each step, and note any
edge cases it does NOT handle.

Explain <topic> for <a beginner / an expert>.
Give the answer as <bullets / a short summary>.
List sources I can verify myself. If you're not
confident about a fact, say so and don't invent
numbers, names, or citations.

📚 Few-shot (copy the pattern)

Turn each product name into a short tagline.
Example:
  Input: SolarMug -> Output: Coffee that warms itself.
  Input: QuietBuds -> Output: Silence, on demand.
Now do these:
  Input: <your item> -> Output:

📋 Quick-Reference Cheat Sheet — the whole course on one page

3 Build your own prompt library

The best prompters keep a personal stash of prompts that worked. Start one today:

• Save the winners — when a prompt nails it, paste it into a notes file.
• Turn it into a template — replace your specifics with <placeholders>.
• Tag by task — writing, coding, research, planning.
• Refine over time — tweak the wording as you learn what works.

Try it for real

Placeholders only help if you never send one by accident. Here is a small renderer for the templates above: it finds every <slot>, lists what a template needs, fills it in, and refuses if a slot is missing or a value is misspelt. That refusal is the whole point — a prompt that still says <audience> in the middle is the most common template mistake.

# A template is text with named slots. A renderer that VALIDATES the slots is
# what stops you sending a prompt that still says <topic> in the middle of it.
# Slots here are written <snake_case>; the library holds two of the section 2
# templates so you can see the slot list generated from the text itself.

import re

LIBRARY = {
    "writing": (
        "Rewrite the text below to be <style>. Keep it under <max_words> words "
        "and keep the key points. Audience: <audience>.\nText: <text>"
    ),
    "research": (
        "Explain <topic> for <level>. Give the answer as <format>. "
        "List sources I can verify myself. If you're not confident about a fact, say so."
    ),
}

def slots(template):
    """Every <name> in the template, in order, without duplicates."""
    return list(dict.fromkeys(re.findall(r"<([a-z_]+)>", template)))

def render(template, values):
    """Fill the slots. Refuse if any slot is missing or any value is unused."""
    needed = slots(template)
    missing = [s for s in needed if s not in values]
    unused = [k for k in values if k not in needed]
    if missing or unused:
        raise ValueError(f"missing={missing} unused={unused}")
    text = template
    for name in needed:
        text = text.replace(f"<{name}>", str(values[name]))
    return text

# 1) What does each template need? A cheat-sheet generated from the templates.
for name, tpl in LIBRARY.items():
    print(f"{name:9} needs: {slots(tpl)}")

# 2) A correct fill: every slot supplied, nothing extra.
print()
print(render(LIBRARY["research"], {"topic": "compound interest", "level": "a beginner", "format": "3 bullets"}))

# 3) A wrong fill: 'audience' forgotten and 'text' misspelt as 'txt'. The
#    renderer refuses instead of sending '<audience>' to the model.
print()
try:
    render(LIBRARY["writing"], {"style": "friendlier", "max_words": 80, "txt": "Dear customer, ..."})
except ValueError as e:
    print("refused:", e)

# Run it. The first lines you should see are below; the rest follows.

# ✅ Expected output:
# writing   needs: ['style', 'max_words', 'audience', 'text']
# research  needs: ['topic', 'level', 'format']

# 🎯 YOUR TURN — finish the renderer so it refuses a half-filled template.

import re

TEMPLATE = "Act as <role>. Task: <task>. Format: <format>."

def render(template, values):
    # 1) Find every slot name written as <name> in the template.
    needed = re.findall(r"<([a-z_]+)>", ___)
    # 👉 replace ___ with  template
    # 2) A slot with no value supplied is missing.
    missing = [s for s in needed if s not in ___]
    # 👉 replace ___ with  values
    if missing:
        return "REFUSED, missing: " + ", ".join(missing)
    text = template
    for s in needed:
        # 3) Swap the <slot> for its value.
        text = text.replace("<" + s + ">", ___)
        # 👉 replace ___ with  values[s]
    return text

print(render(TEMPLATE, {"role": "a careful editor", "task": "tighten this paragraph", "format": "one paragraph"}))
print(render(TEMPLATE, {"role": "a Python developer"}))

# ✅ Expected output:
# Act as a careful editor. Task: tighten this paragraph. Format: one paragraph.
# REFUSED, missing: task, format

⏱ Test Yourself — Timed Quiz

10 quick questions, 12 seconds each. Instant feedback — beat the clock!

🎉 Course Complete — You’re a Prompt Engineer!

• ✅ You can write specific, well-structured prompts for any chatbot
• ✅ You know roles, few-shot examples, and chain-of-thought reasoning
• ✅ You can control the output format and prompt for code
• ✅ You iterate to refine and fact-check to avoid hallucinations
• ✅ You have reusable templates and a cheat-sheet to keep forever

Practice quiz

Continue this course

• Previous: Avoiding Hallucinations & Fact-Checking
• Next: System Prompts & Setting Behavior — Use the system message to set persistent role, tone, rules and guardrails

Frequently asked questions

Why use prompt templates instead of writing fresh each time?

Templates bake the good habits — clear task, context, format, constraints — into a reusable shell. You just fill in the blanks. That gives you consistent, high-quality results in seconds instead of rewriting (and re-learning) the same structure every time you open a chatbot.

What goes into a great all-purpose template?

A role ('act as a careful editor'), the task in one clear sentence, any context the model needs, the output format you want (table, bullets, JSON), constraints (length, tone, what to avoid), and — for tricky problems — 'think step by step'. Not every prompt needs all of these, but the shell reminds you what's available.

How do I use the placeholders?

Anything in angle brackets like <your topic> is a blank to fill in with your own details. Copy the template, swap the placeholders for your specifics, delete any lines you don't need, and send it. Over time you'll tweak the templates into your own personal cheat-sheet.

Do templates replace the rest of the course?

No — they're the shortcut that uses everything you learned: being specific, giving a role, showing examples, asking for reasoning, controlling the format, and fact-checking. Templates get you a strong first draft fast; you still iterate and verify the important parts.