Hamel Husain is a machine learning engineer and data scientist who has worked at Airbnb, GitHub and a long run of startups, and who now teaches engineers and product managers how to measure whether an AI product is working. He is the co-author, with Shreya Shankar, of O'Reilly's Evals for AI Engineers. In this episode, Hamel joins TwoSetAI for a live mini-workshop instead of an interview. Angelina describes the personal assistant she is building for herself, and his first answer is that it does not need evals: with one user who reads every output, she is already doing them implicitly. So they turn it into a product for every podcaster, a hypothetical Angelina.ai, and design its eval system from scratch. His core warning is that the biggest mistake teams make is reaching for generic metrics like helpfulness, coherence or groundedness scores. If a dashboard says your helpfulness score is 3.2, he asks, what are you going to do with that? You can find Evals for AI Engineers here, and Hamel's writing at hamel.dev. We go deep on error analysis as Hamel teaches it. It starts with traces, the full record of a user session, including the system prompt, the tool calls and what was retrieved. He wants a custom annotation interface, so that an email the product sent looks like an email, with its To and CC lines, not a JSON log. Sampling is deliberate: some random traces, targeted searches for problems customers already reported, clusters, and outliers such as sessions with an unusual number of tool calls. Read about 100 traces, not a magic number but a way past the anxiety of starting, and read each one top to bottom, stopping at the first major problem, because upstream errors cause the downstream ones. Write free-form notes, a method borrowed from qualitative research called open coding, then categorize and count them. Counting, in his opinion, is the most powerful data science technique. Some failures you simply fix. The ones that need many experiments earn an eval, and when they do, he wants the LLM judge to be a binary pass/fail classifier, aligned to human labels with a train, dev and test split, not a 1 to 5 score. We also get into the harder parts. Hamel explains why you cannot just tell Claude or Codex to find all the problems: AI can catch obvious engineering failures like misfiring tool calls, but it cannot read your mind, so it misses the places where a product drifts from the experience you intended. That gap is where he says all the alpha is, since every competitor is already using AI to find errors. He treats synthetic data as a backup and a smoke test, and warns that a coding agent hill climbing your evals will cheat if you let it. He argues that evals which all score 100 percent are worthless, that observability is mostly a database for your logs (a small project can start by writing traces to Postgres), and that humans, 100 percent, are accountable when an AI agent gets it wrong: what he buys from software vendors is accountability as a service. He closes on how engineer, PM, data scientist and designer roles are collapsing into fewer people, why the main bottleneck is now building the right thing, and one piece of advice: look at 10 logs, and always read the prompt. We discuss: * The biggest mistake: generic metrics like helpfulness, coherence and groundedness scores * What evals are: product-specific evals versus foundation model benchmarks * A live mini-workshop: designing an eval system for a podcaster's AI assistant * Why a personal assistant with one user probably does not need evals * Where to start: read the logs and write down what is wrong * Cheap, medium and expensive evals: unit tests, classifiers and LLM judges * Building a custom annotation interface that shows data the way users see it * Sampling traces: random, hypothesis-driven, clusters and outliers * Why 100 traces, and reading until you stop learning new things * How to read a trace fast: stop at the first major problem * Why you cannot just ask Claude or Codex to find all the problems * Synthetic data: a backup and a smoke test, built along dimensions you choose * Counting errors to decide what to fix first * Train, dev and test splits for aligning an LLM judge with human labels * Why binary pass/fail beats 1 to 5 and 0 to 100 scores * Letting a coding agent hill climb your evals without cheating * What still needs a human: taste, judgment, and reading the judge's prompt * Why evals that always score 100 percent are worthless, and when to retire them * Reporting a pass-all rate alongside more stable product metrics * Observability versus evals, and starting with Postgres * Accountability as a service: why humans own an AI agent's mistakes * Collapsing roles and the new bottleneck: building the right thing * One piece of advice: look at 10 logs and always read the prompt Hamel Husain * LinkedIn: https://www.linkedin.com/in/hamelhusain/ * Blog: https://hamel.dev * Parlance Labs: https://parlance-labs.com/ * Evals for AI Engineers by Shreya Shankar and Hamel Husain (O'Reilly): https://www.oreilly.com/library/view/evals-for-ai/9798341660717/ * Evals course: https://maven.com/parlance-labs/evals * Mentioned in the episode: Hamel's eval skills for coding agents (https://hamel.dev/blog/posts/evals-skills/); Terminal-Bench Timestamps 00:00:00 The #1 mistake people make with AI evals 00:01:03 Who is Hamel Husain, and what are evals? 00:02:34 Let's build an eval system: a live mini-workshop 00:03:35 Does a personal AI assistant even need evals? 00:04:22 Where to start: read your logs and write what's wrong 00:05:35 Why a generic "3.2" score tells you nothing 00:08:41 What a trace is, and which logs to sample 00:13:22 How many traces do you have to read? 00:14:43 How to read a trace fast 00:19:09 Why you can't just ask AI to find the problems 00:20:25 Can you test your AI on synthetic data? 00:22:56 Which failures should you fix first? 00:25:45 Can you trust an AI judge? Pass/fail vs 1 to 5 00:29:55 Letting your AI improve itself without cheating 00:31:19 What still needs a human 00:33:29 Why a perfect eval score is a bad sign 00:35:49 The one metric worth reporting 00:37:45 Is observability the same as evals? 00:40:15 Who's accountable when an AI agent gets it wrong? 00:41:20 How AI is collapsing engineering roles 00:42:53 One piece of advice for AI engineers 00:43:45 outro Get full access to Decoding AI Builders By Angelina Yang at angelinayang.substack.com/subscribe