Prompt Engineering Workshop

3-Hour Prompt Engineering Workshop:

Course Overview

This 3-hour interactive workshop equips participants with core prompt engineering skills. Through discussions, hands-on exercises, and real-world scenarios, you’ll learn to craft effective prompts and get better results from AI models.

  • Duration: 180 minutes

  • Audience: Practitioners using Claude, GPT, Gemini, Grok, and other frontier models

  • Core Shift: From “clever wording” to outcome specification + context engineering. Reasoning is now largely a dial you set, not a sentence you write.

Workshop Overview

1. Workshop Kickoff & Mindset Shift (10 min)
  • Quick participant check-in: current AI use cases and biggest frustrations.
  • Core message: In 2026 the highest-leverage skill is no longer “writing clever prompts.” It is specifying the desired outcome clearly and curating the right context.
  • Live demo of the same vague request producing widely different quality depending on structure and context.
  • Workshop agreement: Treat every first output as a draft. Iteration is the real skill.
  • Evolution: Classic prompt engineering (wording) → Context engineering (what the model sees: system instructions, retrieved knowledge, conversation history, tool results, memory).
  • Why the shift happened: Reasoning models + long context + agents made pure instruction-tweaking less dominant.
  • What still matters most: Clear goals, success criteria, relevant context, examples for format, and structured output contracts.
  • Practical definition for this workshop: Designing the full information environment so the model can deliver reliable, high-value results.
  • Systems that compound speed:
    • Personal prompt library / snippet system
    • Reusable templates (Role + Goal + Context + Format + Constraints)
    • Voice dictation for thinking out loud
    • Model-specific projects / custom instructions / system prompts
  • “Draft → Diagnose → Refine” as the default workflow instead of perfection on the first try.
  • Quick tip: Version prompts like code when they matter in production.
  • Practical mental model (not deep architecture):
    • Next-token prediction under uncertainty
    • Context window as limited working memory
    • Attention dilution: important instructions can get lost in noise
    • Why models still hallucinate and how good context reduces it
  • Reasoning models vs standard models: internal thinking budget vs external step-by-step instructions.
  • Temperature / sampling still matter, but the biggest new lever is the thinking/effort dial.
  • 2026 best practice: Describe the destination and success criteria more than the exact procedure.
  • Reasoning models perform better when given high-level goals and constraints; excessive step-by-step instructions can hurt.
  • Classic models still benefit from clearer procedural guidance.
  • Examples of over-commanding that make outputs rigid or lower quality versus clean outcome specification.
  • Rule of thumb: Match the level of detail to the model type.
  • Highest-ROI elements to include:
    • Precise role or perspective (only when it adds real signal)
    • Audience and purpose
    • Relevant background / constraints the model cannot know
    • Explicit success criteria (“Done means…”)
    • Preferred tone, length, and format
  • Structure techniques that work across models: clear sections, XML-style tags (especially strong with Claude), Markdown headers.
  • Exercise: Rewrite a vague request into a high-signal context block and compare results.
  • Still one of the strongest techniques for controlling format, style, and edge-case handling.
  • Quality > quantity: 2–5 carefully chosen, consistent examples beat long lists.
  • Best used for shape (output structure, tone, classification boundaries) rather than teaching complex reasoning on modern models.
  • Include at least one near-boundary or edge-case example when reliability matters.
  • Live exercise: Build a short few-shot prompt for a real participant task.
  • Major 2026 change: Reasoning depth is now largely a control (effort / thinking level / budget), not a phrase you append.
  • When to use explicit Chain-of-Thought still: non-reasoning models or when you need visible intermediate steps for verification.
  • When to avoid forced “think step by step”: most frontier reasoning models — it can add latency and noise.
  • Practical guidance: Set the effort dial to match task difficulty, then focus the prompt on outcome and constraints.
  • Brief mention of related patterns (self-consistency, multi-path exploration) and when they are worth the cost.
  • Why structure is non-negotiable for anything that feeds tools, pipelines, or further automation.
  • Native structured output / JSON schema support (preferred) versus prompt-enforced formats.
  • Techniques: schema definition, XML tags, Markdown tables, prefilling the start of the response, validation + retry loops.
  • Always pair structure with a clear “respond only in this format” instruction when using pure prompting.
  • Demo: Turning free-form answers into clean, parseable outputs.
  • Positive constraints outperform heavy negative lists in most cases.
  • Effective patterns: length limits, required elements, style boundaries, scope definitions.
  • Negatives are still useful for hard prohibitions (“never invent citations,” “do not include marketing language”).
  • Risk of over-constraining: models become brittle or refuse useful creativity.
  • Framing tip: Convert “don’t do X” into “do Y instead” whenever possible.
  • The real skill: systematic diagnosis.
  • Diagnosis questions: Missing context? Ambiguous success criteria? Wrong examples? Conflicting instructions? Model type mismatch?
  • Techniques: critique-and-revise, progressive disclosure of requirements, “what’s still missing?”, side-by-side comparison.
  • Lightweight evaluation: keep a small set of real test cases and re-run after changes.
  • Live group iteration: Start with a mediocre prompt and improve it in 3–4 rounds.
  • Pattern: Ask the model to interview you first until it has enough information.
  • Highly effective for ambiguous or complex projects (strategy, specs, learning plans, creative briefs).
  • Control levers: limit number of questions, request prioritization, allow the model to propose assumptions.
  • Demo of turning a vague idea into a high-quality brief through guided questions.
  • System / developer messages vs user messages — persistent rules belong in the system layer.
  • Key parameters: temperature, top_p, and especially reasoning/thinking effort controls.
  • Model family differences (high-level):
    • Claude: Strong with XML structure and extended thinking
    • OpenAI reasoning models: Prefer clear goals over detailed procedures
    • Others: Vary in long-context handling and formatting preferences
  • Emerging patterns: prompt chaining, simple agent loops, self-critique, combining few-shot + structured output + effort control.
  • When pure prompting is no longer enough (tools, retrieval, memory, multi-agent).

Frequent 2026 anti-patterns:

  • Treating reasoning models like 2023 models (forcing step-by-step when the dial exists)
  • Overloading a single prompt with everything
  • Ignoring context quality and only polishing wording
  • No success criteria or evaluation cases
  • Assuming long conversations retain perfect memory of early instructions
  • Copy-pasting prompts across models without adaptation
  • Heavy negative constraint lists instead of positive framing
  • Skipping iteration after the first decent result
  • Key takeaways recap
  • Recommended practice: Keep a prompt journal + small personal eval set for 2 weeks
  • Resources for going deeper (context engineering, evaluation tools, model-specific guides)
  • Open Q&A

Workshop Registration Form


Scroll to Top