Advanced Prompting

Building reusable prompt libraries: from snippets to shared templates

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.

10 min read

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

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.

12 min read

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

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.

More in this topic

10 min read

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

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.

12 min read

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

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.

12 min read

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

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.

7 min read

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

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.

Beginner

13 min read

Structured outputs and function calling: the production patterns

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.

29 minutes

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

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.

25 minutes

Prompting 101

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.

22 minutes

Context Engineering for Agents

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.

8 minutes

Context Rot: How Increasing Input Tokens Impacts LLM Performance

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.

3 minutes

Building OpenAI o1

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.

28 minutes

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

AI Explained. The clearest non-hype explanation of why o1 (and by extension o3, R1, Claude extended thinking) layers reinforcement learning on top of next-token prediction to reward correct multi-step answers, 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.

9 minutes

RAG vs. Fine Tuning

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.

13 minutes

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

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.

77 minutes

AI prompt engineering: A deep dive

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.

25 minutes

Prompting 101 | Code w/ Claude

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.

10 minutes

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

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.

20 minutes

Google's 9 Hour AI Prompt Engineering Course In 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.

41 minutes

OpenAI DevDay 2024 | Structured outputs for reliable applications

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.

18 minutes

Pydantic is all you need: Jason Liu

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.