Advanced Prompting

Building reusable prompt libraries: from snippets to shared templates

When the same AI-assisted task recurs, a prompt library can make the workflow easier to reproduce and evaluate. A practical system for capturing, testing, versioning, and sharing templates.

10 min read

Choosing and prompting reasoning models

Reasoning settings change quality, latency, cost, and sometimes prompting behavior. A practical guide to choosing them by evaluation rather than folklore.

12 min read

Context engineering: testing long-context systems without guesswork

Large context windows are capacity limits, not quality guarantees. Build position, distractor, retrieval, latency, and cost tests for the workload you actually run.

More in this topic

10 min read

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

Three reasoning techniques that can improve AI output on hard problems — and the cost-benefit tradeoffs 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

A governance pattern for separating trusted instructions, runtime data, and user input, then versioning, evaluating, deploying, and observing prompts according to risk.

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, reasoning variants, and open-weights options, with decision rules and mid-2026 examples rather than a timeless ranking.

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. This three-minute first-party video records how the OpenAI team presented o1 at launch. It is useful for understanding the category's history, but it does not establish how current models work internally or which prompting pattern will perform best on a different provider or task.

28 minutes

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

AI Explained. The video offers an independent explanation of the early o1 framing and its prompting implications. It is useful historical context, but its claims about o1 should not be extended automatically to later OpenAI models, R1, Claude thinking modes or other providers.

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. The video demonstrates a C.R.A.F.T. meta-prompt (Context, Role, Action, Format, Target audience). It is a useful candidate for testing how a prompt-generating prompt behaves, but its outputs are not guaranteed to be consistent, correct or suitable for a team's use cases.

20 minutes

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

Tina Huang. Tina presents a five-part task/context/references/evaluate/iterate framework and four named iteration moves. Those elements can help you draft a candidate schema, but the agent and chain-of-thought examples reflect the course's time and context. Test any extracted pattern on representative cases before adding it to an approved library.

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.