Prompt Engineering

Same prompt, different answers. That is not a bug; it is sampling. Learn what temperature really does, and why the dial is disappearing from frontier models.

Raw autocomplete would answer your question with another question. Two extra training stages turned pattern-completers into assistants, and left two famous side effects.

"Which model is best?" is like "which vehicle is best?". Learn the 2026 landscape: capability tiers, reasoning vs standard, and why prompts are calibrated to models.

Two engineers argue about whose prompt is better. Both are guessing. The mindset that ends the argument is the one this whole course is built on.

"Make it better" is an empty brief in every workplace on earth. The single highest-leverage prompting skill is filling in what you actually meant.

When instructions and data blur into one blob, the model answers the wrong thing. Delimiters and sections are the cheapest reliability upgrade in prompting.

The model wrote a great answer wrapped in three paragraphs of chatter your code can't parse. Output specs end the wrapping paper problem.

"Don't mention peanuts" puts peanuts on the desk. Learn why negations backfire, and why one "because" outperforms three rules.

"You are a world-class expert" was the most copied line of 2023. The research verdict is in: roles steer voice and framing, not intelligence.

More context feels safer, and it quietly makes answers worse. Curate the desk: what earns a place, what gets cut, and why contradictions are poison.

Five flawed prompts on the operating table. Diagnose the failure, pick the fix, using everything from Modules 1 and 2.

You wrote ten lines describing the format you want. One worked example would have said it better, in the model's native language.

Three easy, samey examples teach less than three that span the range. Pick examples like a teacher building a worked-problem set.

The model learns everything your examples show, including the things you didn't notice you were showing. Four traps, and the modern caveat that changed few-shot advice.

Production prompts aren't typed, they're assembled: a fixed scaffold plus per-request values. That split unlocks testing, caching, and versioning, and creates one famous hazard.

Assemble a production-grade few-shot classifier step by step: label set, examples, template, and the traps you now know how to dodge.

A model that answers instantly commits to its first guess, token by token. The most famous trick in prompting history exists because of that one-way street.

A new model class thinks privately before it answers. The 2023 playbook of step-by-step micromanagement now backfires, and the new skill is prompting at the right altitude.

The mega-prompt that classifies, extracts, rewrites, AND translates does all four at a C-minus. Pipelines of focused calls beat one overloaded call, when you know the trade.

"Are you sure?" makes the model fold. Checklists make it verify. Learn the difference, plus the fresh-eyes trick that catches what self-review can't.

ReAct, Tree of Thoughts, self-consistency: the greatest hits of 2023 prompting, stamped honestly: still core, absorbed into the platform, or retired folklore.

Six scenarios, six judgment calls: CoT or not, chain or single call, checklist or critic, dial or prose. The whole module, under load.

Every API request is a cast of roles: system, user, assistant. Who says what determines who gets obeyed, and putting rules in the wrong seat is a real production bug.

Production system prompts aren't essays; they're organized like legal documents crossed with onboarding guides. Learn the standard sections and the minimalism rule that keeps them alive.

Enough toy examples. Here is Mira, a production-grade support-bot system prompt, taken apart line by line: every section, every decision, every scar from a real incident.

"Be friendly and professional" produces the same beige voice as every other bot. Real voice control ranks values, shows samples, and adapts to who is reading.

Turn 3, the bot is sharp. Turn 40, it's rambling and has half-forgotten its job. Long conversations decay in predictable ways, and there are engineering fixes for each.

Models bluff because we accidentally demand it: every prompt that requires an answer forbids "I don't know". Honesty is a designed behavior, and you are the designer.

A blank page and a real product: assemble a production system prompt decision by decision, dodging every failure mode this module named.

"Respond ONLY with valid JSON" fails just often enough to page you at 3am. The modern fix isn't better begging; it's a contract the API enforces.

Field names steer content. Descriptions are instructions. Enums pin vocabularies. Nullable is the honesty escape hatch. Schema design is prompt engineering with types.

The schema guarantees shape; nothing guarantees sense. The repair loop is the few lines of code standing between "valid JSON" and "correct data".

The model can't check your database, today's weather, or a calculator, but it can ASK. Tool calling is the loop that turned text-predictors into systems that act.

When an agent picks the wrong tool, passes garbage arguments, or ignores a tool entirely, the bug is almost always in the drawer labels: the tool definitions.

Max tokens, stop sequences, verbosity dials, and a eulogy: the prefill trick served faithfully for years, then one API generation deprecated it overnight. Techniques rot; mechanisms survive.

Invoices in, clean database rows out: design the whole pipeline: schema, repair loop, tools, caps, decision by decision.

Hallucination isn't a glitch to patch; it's the default output of an ungrounded pattern engine. Understanding the mechanism tells you exactly which cures work.

Turn the closed-book exam into an open-book one: retrieved documents on the desk, answers restricted to the book, and the placement rules that measurably change accuracy.

"Trust me" is not a product. Citations turn answers into checkable claims, and a well-designed IDK turns retrieval misses into user trust instead of user churn.

Million-token windows tempted everyone to stop curating and start dumping. Then the measurements came in: attention is a budget, and big desks are not tidy desks.

Mid-2025, the industry quietly renamed the job. Prompt wording is one input; the real discipline is deciding everything that occupies the window: instructions, tools, examples, history, retrieval.

Some work outlives any context window: day-long agent runs, week-long projects. The pros survive on three moves: compact the past, externalize the state, restart fresh on purpose.

Mira graduates: from hardcoded facts to a grounded, cited, context-engineered support bot. You make every call.

An agent is not magic: it's a model, tools, and a loop that keeps running until the job is done. Knowing the workflow patterns tells you when you need one, and when you emphatically don't.

Three paragraphs of harness instructions moved a major coding benchmark by about 20%. Persistence, tool-grounding, and planning: plus the stop conditions and budgets that keep loops from running forever.

One agent asks permission to read a file; another force-pushes to main unprompted. Autonomy is a dial with two failure directions, and the confirm-first line is yours to draw.

One agent, one window, one exhausted desk: or a lead that delegates focused missions to workers with clean desks. Multi-agent design is context engineering by other means.

The highest-ROI prompt most engineers will ever write isn't in an app: it's the rules file in their repo that every coding-agent session silently reads first.

Same agent, same repo: one engineer gets a mess, the other gets a mergeable PR. The difference is the brief: spec-shaped tasks, plan-first flows, test anchors, and real review.

Six agent scenarios: harness holes, autonomy calls, orchestration choices, rules-file triage, and brief surgery. The whole module, under load.

You have watched this attack five times without its name. When user content becomes user commands, that is prompt injection: the defining security problem of AI applications.

The scary injections don't come from your user: they come from a web page, an email, a document your agent reads on their behalf. Three capabilities together turn that into data theft.

No single defense stops injection, so you stack several imperfect ones. Marking untrusted content, least privilege, human approval, and output checks: each leaks, together they hold.

Jailbreaks try to talk a model out of its safety training. The professional response isn't a cleverer refusal prompt: it's enforcing policy in layers the conversation can't touch.

No attacker required. Prompts rot on their own: format drift, verbosity creep, prompt sensitivity, and the silent model update that changes everything overnight.

Prompts and outputs don't vanish: they persist in logs, histories, and traces. What you put on the desk can outlive the conversation, so minimize what goes there.

Six systems on the security bench: find the injection vector, the trifecta violation, the missing layer, the leak. Defense reps, using all of Module 9.

This is the module that separates hobbyists from professionals. It starts by killing the vibe check with the thing every serious AI team is built on: a golden dataset.

A golden dataset needs a grader. Use the cheapest one that works: code where you can, an LLM judge where you must, and never trust a judge you haven't validated against humans.

The whole idea fits in about 40 lines of Python: load cases, run the prompt, grade each, diff two versions. Once you see it, 'test your prompts' stops being abstract.

The eval harness only pays off when it's wired into how prompts ship: versioned, reviewed, gated by evals in CI, rolled back on regression, and re-baselined on every model change.

A prompt that works but costs 10x too much is a failed prompt. Cost and latency engineering: caching-aware design, model routing, batching, and output discipline.

Evals test before you ship; observability watches after. Trace every call, build failure taxonomies from real traffic, and catch the drift that no pre-release test could predict.

The frontier of the field: metaprompting, vendor optimizers, and DSPy-style automatic optimization. Powerful tools that need the one thing only you can provide: the eval that defines 'better'.

Mira, fully realized: system prompt, examples, structured outputs, tools, grounding, an agent harness, injection defenses, and evals. Every module, one production system.