• Format — 1,400+ MCQs with instant explanations
• Duration — about 16 hours of focused practice, typically 3–5 weeks at 40–60 questions a day
• Level — beginner to advanced; LLM Foundations recommended first
• Cost — free, with a public-URL completion certificate
• Audience — engineers shipping LLM-backed features, AI Engineer interview candidates, builders organising scattered prompting tricks into a library
• Next courses in the track — RAG Systems, AI Agents

Three audiences land on this page. Working software engineers and data scientists who have shipped a chatbot, a copilot, or an LLM-backed feature and now need to make it reliable — robust to weird user inputs, resilient to prompt injection, cheaper to run, and consistent across model upgrades. Final-year engineering and MCA students targeting AI Engineer / ML Engineer interviews in 2026, where "design a prompt for X" is now a standard whiteboard question and the bar is concrete pattern fluency, not vague hand-waving. Self-taught builders who have collected scattered prompting tricks from blog posts and Twitter and want them organised into a real pattern library with the tradeoffs spelled out.

Foundations

• Foundations of Prompting — what a prompt actually does (input distribution shift, in-context learning), the anatomy of a prompt (system vs user vs assistant messages, delimiters, structure markers), and the common misconceptions that waste tokens or budget
• Zero Shot and Few Shot Prompting — direct instruction patterns, role assignment, task description specificity, output format declaration; example selection strategy, ordering effects, label balance in classification, and when few-shot beats zero-shot
• Chain of Thought and Reasoning — explicit reasoning traces, the "think step by step" trigger, zero-shot vs few-shot CoT, self-consistency for harder tasks, tree of thoughts exploration, and reasoning failure modes (plausible-but-wrong, shortcut reasoning, contradiction with final answer)

Patterns

• Structured Output and Formatting — JSON, Markdown, XML and key-value output requests; JSON schemas in the prompt, function-calling APIs, tool-use schemas, constrained decoding, strict-mode toggles; tolerant JSON parsing, retry-with-corrective-prompt, field-by-field extraction
• Role and Persona Prompting — expert persona framing, audience adaptation, tone control, persona drift, stereotype risk, the role-vs-system-instruction distinction, and multi-agent personas (debater, critic-and-writer, panel of experts, self-critique)
• Decomposition and Workflows — splitting complex tasks, sequential chaining, least-to-most prompting, plan-then-execute; classify-then-dispatch routing, conditional execution, fallback chains; self-critique-then-revise, verifier loops, stop-condition design, infinite-loop prevention
• ReAct and Tool Calling — the thought-action-observation loop, tool selection reasoning, termination criteria; function-calling syntax, argument schema precision, tool description specificity for routing, tool result formatting; hallucinated tool calls, wrong argument types, infinite tool-calling loops

Production and Interview readiness

• Prompt Injection and Safety — direct vs indirect injection, jailbreak prefixes, role override, instruction smuggling in data; input sanitization, instruction-system separation, least-privilege tool exposure, output filtering, user vs untrusted-source labelling; data exfiltration via markdown links, images, and tool outputs
• Prompt Optimization and Evaluation — single-variable changes, A/B testing prompts, edge case probing, regression suites; APE (automatic prompt engineer), evolutionary tuning, DSPy compilation; task accuracy metrics, format adherence rate, robustness to paraphrasing, cost vs quality tradeoff
• Model Specific Behaviors — cross-model portability gaps, chat-template differences, instruction-following strength variation, context-window differences; temperature for creative vs deterministic tasks, top-p for diversity control, stop-sequence design; small vs large model prompting; reasoning-model (o1-style) prompting, prompt caching strategies, prefill, system-prompt anchoring
• Prompt Engineering Mastery — head-to-head pattern comparisons (zero-shot vs few-shot, CoT vs direct, ReAct vs plan-and-execute, self-consistency vs single-sample) and when-to-use selection across few-shot examples, chain of thought, tool calling, multi-prompt chains, and fine-tuning

LLM Foundations teaches how the model works under the hood — tokenization, attention, decoding, RLHF, why models hallucinate. Prompt Engineering teaches how to make the model do what you want from the outside. The two are complementary, and most learners take them in this order. Why? Because every advanced prompting pattern (chain of thought, self-consistency, structured output, prompt injection defence) makes much more sense once you know what is happening inside the model when it reads your prompt. You can take Prompt Engineering first if you already know transformers, but expect to wonder "why does this work" until you fill the gap. Prompt Engineering is also the prerequisite for the next two modules in the track — RAG Systems and AI Agents — both of which depend on advanced prompting patterns introduced here.

Most production prompting failures come from a small set of recurring anti-patterns. This course is designed to surface and correct them through targeted MCQs. Among the most common:

• Polite phrasing ("please", "thank you") has no measurable effect on output quality — structural clarity does.
• "You are a senior X with 20 years of experience" doesn't unlock real knowledge — persona can only adjust tone and reduce hedging.
• Few-shot example ordering matters — many models weight the last example most heavily, and skewed example order biases classification labels.
• Chain of thought is not free — on tasks where the model isn't actually reasoning, CoT only adds token cost without improving accuracy.
• Indirect prompt injection via retrieved documents is the real attack surface in production — not the dramatic direct jailbreak prompts users post on Twitter.
• Prompts that work on Claude often need rewriting for GPT or Gemini — instruction-following strength, chat-template format, and system-prompt anchoring all differ.
• Temperature 0 does not give determinism in production — server-side batching, sampling library defaults, and GPU non-determinism leak in.
• A/B testing prompts without a regression suite ships systems that quietly degrade as the model is updated.
• Reasoning models (o1, Gemini Thinking, Claude with extended thinking) often need less steering, not more — over-prompting them suppresses the reasoning trace.
• Magic-word folklore ("take a deep breath", "I will tip you $200") does not survive systematic evaluation — the prompt-engineering literature is heavily contaminated with unreproducible advice.

Each of these has a dedicated cluster of practice questions in the curriculum.

Read fewer blog posts. Practice more patterns. Most engineers who try to learn prompting from Twitter threads end up with a collection of half-remembered tricks that don't generalise. Answering 1,400+ specific MCQs — with the explanation appearing immediately after every wrong answer — forces retrieval practice on every pattern. The Abekus AI guide also tracks which subtopics you keep missing and re-surfaces them in later sessions, so weak spots compound less.

One question at a time. Pick an answer. If you are wrong, the explanation appears immediately — usually a paragraph that walks through the pattern, names the standard term (CoT, ReAct, few-shot, tool calling), and points at the related labels in the curriculum. The AI guide watches your accuracy by subtopic and prioritises the weak ones in the next practice session. There is no video, no scrolling lecture, no playback speed to fiddle with — just focused retrieval practice on the patterns you actually need to ship.

The honest math: 1,400+ MCQs at about 40 seconds each (including reading the explanation on the wrong ones) is roughly 16 hours of pure focus. Spread that over 40–60 questions a day and you finish in about 3–5 weeks. At 80 questions a day, about 2.5 weeks. The course is designed for short ad-hoc sessions of 20–30 minutes — you do not need to block off a weekend. Most learners finish all four modules of the Generative AI Engineering track in 3–4 months at this pace.

The mastery topic at the end mirrors the prompting questions that actually get asked in AI Engineer technical screens in 2026 — zero-shot vs few-shot, CoT vs direct, ReAct vs plan-and-execute, self-consistency vs single sample, when to chain prompts vs fine-tune, when to add few-shot examples vs increase model size. The Prompt Injection and Safety topic mirrors a different round that has become standard at companies shipping LLM products to enterprise — "walk me through how you'd defend against indirect prompt injection in a customer support agent". The In-Practice labels (document QA, code generation, classification at scale, customer support agents, data extraction pipelines) cover the most common scenario-based prompts.

The natural next step is RAG Systems — the third module in the Generative AI Engineering track. AI Agents follows as the fourth. Finishing all four unlocks the Generative AI Engineering series certificate. Independently of the GenAI track, learners targeting Data Scientist or ML Engineer roles often pair Prompt Engineering with the Machine Learning Foundations and Statistics for Data Science courses on Abekus.