Three episodes that frame prompt engineering as a real discipline, not a vibe. Why the same prompt produces different outputs across models and across runs (the explanation is mostly architectural, and once you understand it the workarounds become obvious). What 'reproducible' means in practice (and why most people's working prompts aren't). The structural moves that turn a one-shot question into a reliable building block. Written for the operator who's already paying for ChatGPT, Claude, or both, and is tired of treating each conversation as an experiment with sample size one.

The book that replaces prompt-by-vibes with a working method. Covers the architectural reasons LLMs behave the way they do (so the techniques aren't superstition), the prompt patterns that survive model upgrades (and the ones that don't), the structural moves that compound — chain-of-thought when it actually helps versus when it makes outputs worse, few-shot when the cost is justified, structured output formats that turn AI from a chat interface into a software component. Worked examples in domains the reader probably uses daily: code review, content drafting, structured data extraction, summarisation under length constraints. Built for the operator who's noticed that good prompts aren't accidents and wants the engineering version.

The gate between 'this prompt works on my desk' and 'this prompt is part of a workflow that ships'. Walks through the production-readiness checks most prompts fail: edge cases the original tester didn't think of, output format stability across model temperature settings, refusal handling, the eval set required to spot regression when the model behind the API gets quietly upgraded next month. Run before any prompt becomes a dependency. The list isn't long but each item has saved someone a production incident. Pair with the testing patterns from the book and the prompt pack for the full pipeline from drafting to shipping.

The detailed sibling of the book's chapter on prompt structure. Walks through the moves that turn a prompt from one-shot question into a reliable function: input containment (so adversarial input can't redirect the system instructions), output structure enforcement (XML, JSON, the structural choices that catch malformed responses early), the instruction-comes-last pattern when context is long, the few-shot example selection rules. Specific to current-generation models with notes on what does and doesn't transfer to smaller ones. For when 'it works on my prompt' isn't sufficient and the prompt needs to survive in a system.

The seven prompt patterns that quietly multiply how much time AI ends up costing rather than saving: vague tasks ('make this better'), no output structure (so each response needs reformatting), context dumped at the end (so the model attends to it less), polite phrasing that obscures the actual instruction, missing constraints (length, format, style), no example of what 'good' looks like, single-shot expectations on tasks that need iteration. Each gets a one-line fix. The pattern across all seven: most operators use AI like they'd use a search engine; the failure mode is treating chat output as final rather than as a draft to be structured.

Eight email lessons that walk through the engineering moves for daily-use prompts. By session three the recipient has rebuilt three of their existing 'works most of the time' prompts into reliable building blocks. Sessions four through six cover the harder patterns — tool use, structured output, multi-turn coordination. Sessions seven and eight close on testing and the prompt-as-software discipline that separates someone who 'uses ChatGPT' from someone who's actually integrated AI into their workflow. Every lesson lands with one specific prompt to refactor, not theory to admire.