Advanced Prompting

Once you use AI seriously, you write the same kinds of prompts over and over. A practical system for building, organising, and sharing a prompt library — what to capture, how to version, and what infrastructure to use.

Building reusable prompt libraries: from snippets to shared templates

Turn individual prompts into shared, versioned templates with owners, examples, and quality checks.

10 min read

Reasoning models are not fast models with extra steps. They reward different prompting, ignore some conventional patterns, and have their own pitfalls. A practical guide to working with them well.

Prompt engineering for reasoning models (o3, R1, Claude extended thinking)

Evaluate the implementation pattern, failure modes, and guardrails before building.

12 min read

1M-token context windows exist, but quality degrades long before that limit. Context engineering is the discipline of using context windows effectively — what to include, what to summarize, what to retrieve fresh, and the patterns that keep quality high as context grows.

Context engineering: managing 1M-token windows without context rot

Evaluate the implementation pattern, failure modes, and guardrails before building.

Prompting, RAG, and fine-tuning are the three big levers for adapting LLMs to your problem. Each is right for some problems and wrong for others. A framework for choosing, the realistic costs of each, and the production patterns where combining them shines.

Choosing between prompting, RAG, and fine-tuning (and when to combine)

Use the article as decision context for adoption, risk, governance, or investment choices.

12 min read

Production prompts are not 'tell the AI what you want'. They are a layered system — stable instructions, dynamic context, per-call variables — managed like code. The architecture, the patterns, and the discipline that distinguishes production from prototype.

Designing prompts for production: system, developer, and user layers

Separate system, developer, and user instructions and test production prompts as versioned system components.

13 min read

Structured outputs and function calling are the bridge from 'LLM that generates text' to 'system that does work'. In production, the patterns that matter are about schemas, error handling, idempotency, and graceful degradation — not just JSON mode.

Structured outputs and function calling: the production patterns

Evaluate the implementation pattern, failure modes, and guardrails before building.

10 min read

Three reasoning techniques that genuinely improve AI output on hard problems — and the cost-benefit math of using them. With concrete prompts, side-by-side comparisons, and the gotchas modern reasoning models introduce.

Chain-of-thought, self-critique, tree-of-thoughts — when to use each

Evaluate the implementation pattern, failure modes, and guardrails before building.

7 min read

Which model to reach for, by task type. GPT, Claude, Gemini, the reasoning models, and the open-weights options — sorted by what they are actually best at, with simple decision rules.

Picking the right model for the job: a 2026 decision cheat sheet

Turn the workflow into a small practical experiment with a clear quality check.

Beginner

22 minutes

LangChain. Lance Martin's framework — write, select, compress, isolate — with concrete examples of when to summarise an action history, when to offload state to files, and when to spin up sub-agents purely to protect the parent's context. Maps almost directly onto the article's section on managing 1M-token windows in practice.

Context Engineering for Agents

8 minutes

Chroma. Kelly Hong walking through Chroma's research on 18 models — why needle-in-haystack scores are misleading, how performance degrades with ambiguity and distractors, why even simple string-repetition tasks degrade past 500 tokens. Short, evidence-based, and exactly the case the article needs you to take seriously before getting to the engineering moves.

Context Rot: How Increasing Input Tokens Impacts LLM Performance

9 minutes

IBM Technology. Tighter focus on the two techniques teams most often confuse. Goes deeper on data freshness, source attribution, and the inference-time speed argument for fine-tuning. Worth watching if you are specifically trying to argue against an unnecessary fine-tune project.

RAG vs. Fine Tuning

13 minutes

IBM Technology. A clear whiteboard pass through all three techniques with their respective costs — retrieval latency, training compute and catastrophic forgetting, the limits of prompt-only solutions — and the combinations that actually make sense in production. The closing example of a legal AI system using all three is almost exactly the article's "when to combine" argument.

RAG vs Fine-Tuning vs Prompt Engineering: Optimizing AI Models

25 minutes

Anthropic. A live build session by Anthropic's Applied AI team on an insurance-claims prompt — they start with a vague instruction and iterate to something a developer would actually ship, showing the kind of revisions the article describes for the system and developer layers. Watch this before re-reading the article's checklist on examples, output structure, and refusal handling.

Prompting 101 | Code w/ Claude

77 minutes

Anthropic. Four Anthropic prompt engineers (research, alignment, applied, developer relations) talking at length about what they actually do day to day — how they edit prompts under pressure, how they think about "honesty" in instructions, when XML scaffolds help, when they don't. The article's layered model maps cleanly onto how they describe the work; this is the best way to hear that mental model out loud.

AI prompt engineering: A deep dive

41 minutes

OpenAI. Walks through `strict: true`, the difference from old JSON mode, refusal handling, and how function calling and response-format schemas compose. Useful precisely because it describes the contract the API gives you, which is what the article's production patterns are built on top of.

OpenAI DevDay 2024 | Structured outputs for reliable applications

18 minutes

AI Engineer. The talk that crystallised the modern "define a Pydantic model, hand it to the LLM, let validation do the rest" pattern, with concrete examples of nested objects, validators that catch hallucinated URLs, and Chain-of-Thought as a typed field. Watch it before re-reading the article's section on validators and you will recognise where its retry and refusal rules come from.

Pydantic is all you need: Jason Liu

3 minutes

OpenAI. Three minutes with the o1 team describing the moment the model started questioning its own reasoning during RL training. Useful as the primary source for the article's claim that the chain-of-thought is now happening inside the model, not in your prompt.

Building OpenAI o1

28 minutes

AI Explained. The clearest non-hype explanation of why o1 (and by extension o3, R1, Claude extended thinking) is trained for correctness instead of next-token prediction, and what that means for how you talk to it. Watch this and the article's "stop saying think step by step, start writing the spec" advice stops feeling arbitrary.

o1 - What is Going On? Why o1 is a 3rd Paradigm of Model + 10 Things You Might Not Know

29 minutes

Yannic Kilcher. Yannic walks through the original Tree-of-Thoughts paper from Princeton/DeepMind — the generate-score-prune-backtrack loop, why it lifts Game of 24 accuracy from 4% to 74%, and where the technique stops being worth its 10× token cost. Useful precisely because it forces you to see ToT as a search algorithm, not a magic prompt prefix.

Tree of Thoughts: Deliberate Problem Solving with Large Language Models (Full Paper Review)

25 minutes

Anthropic. Two members of Anthropic's Applied AI team build up a real-world prompt live, layering in role, structured sections and explicit thinking steps. It's the most credible "how to use chain-of-thought without ritualizing it" demo on YouTube, and it makes the article's "stop pasting Let's think step by step into everything" point concrete.

Prompting 101

10 minutes

Lawton Learns. A concrete, copy-pasteable C.R.A.F.T. meta-prompt (Context, Role, Action, Format, Target audience) that the article references in spirit. Useful as the first entry in a new library — a prompt whose job is to generate well-structured prompts for everyone else.

The best ChatGPT Prompt I've ever created - I spent 2 months curating this prompt to write prompts

20 minutes

Tina Huang. Tina compresses Google's full prompting course into the two things a library actually stores: a five-part task/context/references/evaluate/iterate framework, and four named iteration moves to tighten a prompt over time. She also walks through agent and chain-of-thought patterns, so the same video doubles as the entry point for the more advanced templates you'll add to the library later.

Google's 9 Hour AI Prompt Engineering Course In 20 Minutes