| # | Section | Format | Time |
|---|---|---|---|
| 1 | Foundations — AI & ML background vocabulary | Self-paced reading | 25 min |
| 2 | Anatomy of a Prompt — the 5-element framework | Lecture + worked examples | 30 min |
| 3 | Prompting Types — zero-shot to chain-of-thought | Interactive examples | 40 min |
| 4 | Stepwise Practice — build & refine prompts | Live sandbox | 45 min |
| 5 | Ethics & Limitations | Discussion + case studies | 20 min |
| 6 | Knowledge Check — 10 questions | Individual assessment | 15 min |
New to AI? Start with the Foundations tab. It explains every technical term — from "neural network" to "temperature" — in plain language with historical context. You can revisit it any time.
Everything you need to know before writing your first prompt — from what "AI" actually means, to the history of language models, to the vocabulary used throughout this module. No prior knowledge assumed.
Artificial Intelligence (AI) is the broad field of building computer systems that can perform tasks that would normally require human intelligence — understanding language, recognising images, making decisions, solving problems.
Machine Learning (ML) is a subset of AI where systems learn patterns from data rather than being programmed with hand-written rules. Given enough examples, the model learns to generalise — to handle new inputs it has never seen before.
A neural network is a type of ML model made of layers of mathematical units ("neurons") that transform an input into an output. Each connection has a weight — a number — that is adjusted during training to improve the model's accuracy.
Training is the process where a model adjusts its internal weights by seeing millions or billions of examples and learning to predict correct outputs. Modern language models are trained on text from the internet, books, and code over weeks on thousands of specialised chips.
A Large Language Model (LLM) is a neural network trained on vast amounts of text that can generate, summarise, translate, reason about, and converse in natural language. "Large" refers to billions of learned parameters (internal numbers).
A token is a chunk of text — roughly a word or word fragment — that an LLM processes one at a time. Models don't see letters; they see tokens. Each token is converted to a number, processed, and the model predicts the next most likely token.
Temperature is a setting (usually 0–2) that controls how predictable or creative a model's output is. At temperature 0, the model always picks the most likely next token. At high temperature, it picks more surprising words — more creative, but also less accurate.
The context window is the maximum number of tokens a model can consider at once — including your prompt, the conversation history, and the model's reply. Content outside this window is forgotten.
Inference is when a trained model runs on an input to produce an output. Unlike training (which takes weeks), inference is fast — seconds. LLMs generate text one token at a time, each token informed by everything before it.
A hallucination occurs when an LLM generates text that is grammatically fluent and confident-sounding but factually wrong or entirely fabricated. The model predicts plausible text, not verified truth — it has no internal fact-checker.
A prompt is the text input you send to an AI model. It is your instruction, question, or context. The quality, specificity, and structure of your prompt is the single biggest factor in the quality of the output you receive.
A system prompt is a special set of instructions sent to the model before the user's message, usually set by the application developer. It defines the model's persona, constraints, and behaviour rules. Users typically cannot see it.
Role prompting (also called persona prompting) tells the model to behave as a specific expert, character, or persona. This frames the model's response style, vocabulary, and perspective — often producing more focused, domain-appropriate answers.
Output format instructions tell the model how to structure its response — as a bullet list, JSON, table, numbered steps, a poem, markdown, etc. Without format instructions, the model chooses whatever seems natural, which may not suit your use case.
Iteration is the practice of refining and improving your prompt based on what the model returns. Rarely is a first prompt perfect. Effective prompt engineers treat prompting as a dialogue — they read the output critically and adjust constraints, examples, or framing.
Guardrails are safety constraints trained into LLMs that prevent them from producing harmful, illegal, or misleading content. When a model refuses a request, it is because the request triggered one of these constraints — not because it "can't" do it technically.
How to use this framework: You don't always need all five elements. Simple questions may only need Task. Complex tasks benefit from all five. Work through them in order and omit what isn't relevant.
Assign the model an expert identity. This shapes vocabulary, depth, and perspective. The more specific the role, the more calibrated the answer.
The model shifts from generic knowledge to domain-specific framing — it will use pandas/matplotlib terminology, assume business context, and avoid over-explaining basics.
State the action verb clearly. Be specific about the deliverable. Avoid vague requests like "help me with" or "tell me about".
Paste in relevant documents, data, or background. The model cannot browse the internet (unless given a tool) — anything it needs to know must be in the prompt.
Add boundaries: word limits, audience level, tone, things to exclude, factual scope. Constraints prevent the model from making assumptions that don't match your needs.
Tell the model exactly how to format its answer. This is especially important when the output will be read by humans in a document, or processed by code.
Problems: No audience level. No format. No length. No purpose. Model will produce generic textbook content.
Result: Calibrated to audience, constrained length, includes analogy, ends interactively.
How to use this section: Read all six techniques in order — each one builds on the previous. Use the jump-nav below to revisit any technique quickly.
Identify the problem with each weak prompt below. Click to reveal the diagnosis and improved version.
How to use this section: Each tab shows production-grade code patterns. Copy the snippets into your own environment and adapt them. Techniques map 1-to-1 with the Prompting Types tab.
No examples given — model uses its pre-trained knowledge. The BART MNLI model lets you pass any candidate labels without fine-tuning. Great for prototyping on Kaggle datasets where labels aren't fixed.
Kaggle tip: BART-MNLI is a zero-shot powerhouse — no fine-tuning needed. Swap candidate_labels freely between datasets without retraining.
Provide 2–5 labeled examples directly in the prompt. Teams on the LegalBench leaderboard found 3–5 shots outperform zero-shot by ~8 F1 points on edge cases. Consistent formatting (Clause / Label pairs) is the key.
Why it works: Consistent Clause / Label formatting teaches the model the exact pattern. The final Label: with no value is the prompt — the model completes it.
| Scenario | Best Technique | Real-World Source |
|---|---|---|
| Classify text with custom labels, no training data | Zero-Shot (BART-MNLI) | HuggingFace zero-shot-classification |
| Custom output format, consistent across many inputs | Few-Shot (2–5 examples) | Kaggle LegalBench (+8 F1) |
| Multi-step maths or logic, need auditable reasoning | Chain-of-Thought + self-consistency | Kaggle MATH / GSM8K (74%→89%) |
| Domain-specific depth, calibrated reading level | Role Prompting + format lock | Kaggle Science Exam (+4.2%) |
| Output fed into code or a database | Structured Output (JSON schema / Outlines) | HuggingFace Outlines library |
| Question answering over private or recent documents | RAG (retrieve then generate) | HuggingFace FAISS + MiniLM |
| Long-form writing or complex analysis needing polish | Iterative Refinement (2–3 rounds) | Kaggle LMSYS Arena (+6 Elo) |
Industry practices, trends, and agentic AI applicability — mapped to current LangChain / LangSmith documentation and LangGraph patterns.
| Strategy | LangChain class / API | LangGraph role | Token cost | Structured out | Multi-turn | Agent fit | LC doc status |
|---|---|---|---|---|---|---|---|
| Zero-shot | PromptTemplate | Simple node prompts | Low | ✕ | ✕ | 4/10 | Legacy |
| Few-shot | FewShotChatMessagePromptTemplate | Example injection in system prompt | Medium | Partial | ✓ | 6.5/10 | Active |
| Chain-of-thought | ChatPromptTemplate + system msg | Planner / reasoner node | High | Partial | ✓ | 9/10 | Active |
| ReAct | create_react_agent (LangGraph) | Core agent loop Think→Act→Observe | Very high | ✓ | ✓ | 10/10 | Recommended |
| Role / Persona | ChatPromptTemplate system msg | Agent identity / specialization | Low | Partial | ✓ | 7/10 | Active |
| Structured output | with_structured_output() / bind_tools() | Output node, tool-call parsing | Medium | ✓ | ✓ | 9.5/10 | Recommended |
| Memory / history | MessagesPlaceholder + MemorySaver | Stateful graph across turns | High | ✓ | ✓ | 9/10 | Active |
| Prompt versioning | LangSmith commits + tags | Prod/staging lifecycle | — | — | — | — | Recommended |
| pipe operator replaces all chain classes