@yibie: Recommend this: Hamel Husain—one of the world's most experienced AI eval practitioners—said: "It's hard to evaluate" is itself a product smell. If you don't provide users with inspectable intermediate artifacts, they'll redo your work to verify the output. Then what value does your product bring them?...

X AI KOLs Timeline News

Summary

The article recommends and summarizes Hamel Husain's blog, pointing out that "hard to evaluate" is inherently a product design flaw. It advocates prioritizing the design of products that are easy for users to verify, and illustrates through three cases—an AI data analysis agent, a lesson plan generator, and a workplace injury report—how providing inspectable intermediate artifacts enhances product value.

Recommend this: Hamel Husain—one of the world's most experienced AI eval practitioners—said: "It's hard to evaluate" is itself a product smell. If you don't provide users with inspectable intermediate artifacts, they'll redo your work to verify the output. Then what value does your product bring them? "It's Hard to Eval" Is a Product Smell I've been doing AI eval for three years. The most common objection I hear is "our product is hard to evaluate." This objection itself is a product smell—what's hard for you to verify is also hard for your users. More importantly: design a product that is easy to verify, and do it before writing any eval. Example 1: AI Data Analysis Agent Almost every company is building an internal analysis agent. Ask it a business question, it finds data sources, runs queries, gives an answer. The goal is to reduce dependency on data analysts. The most common mistake: making the "answer" the only output. The interface shows only a single number—"Product A's Net Revenue Last Quarter: $4.21M." Users have no way to verify other than redoing everything themselves. A better design doesn't hide the process; it gives users inspectable artifacts. When a data analyst verifies a metric, they do six things: cross-check intermediate calculations and totals against trusted sources, confirm the precise definition of the metric, verify plausibility of related quantities, disaggregate the aggregate numbers by dimensions, read the SQL, and document what cannot be verified. A good AI data analysis agent should do the same—show sources, assumptions, and unverifiable questions in its answer. Users can click to open a notebook and see the full analysis: the assumptions the agent made, the queries it ran, the breakdown by region, and explicitly listed "parts that cannot be verified." Each item is preserved as a runnable cell so users can drill down further. What This Means for Eval If your product is designed for easy verification, annotation costs drop and eval can extract better signals. More importantly, you'll ship a better product. Example 2: PE Lesson Plan Generator A founder built a product: teachers input constraints (grade level, duration, indoor/outdoor, equipment), and the AI writes a lesson plan. "How do you evaluate a good lesson plan?"—Hamel flipped the question: what do teachers care about? The fastest way is to see "a lesson plan that a teacher like you has already used." A better design: instead of generating a plan from scratch, start from a trusted plan that has been reviewed, is in use at 14 schools, and has run 30+ times this year. Then only show what has changed—"Shortened to 45 min, changed warmup from 2 laps to 1" "Matched your equipment, 4 stations to 3." The teacher doesn't review a full plan but a diff—cognitive load drops dramatically. Eval also becomes more traceable: you only need to verify that the retrieved plan is reasonable and that every modification respects the constraints. Example 3: Workplace Injury Medical Report A product generates a 50-page expert opinion from medical records (MRI, physiotherapy notes, exam reports). The problem: doctors are responsible for the report, so they re-read all the records and check each point—taking as long as writing from scratch. The product provides no value. Hamel suggested turning the product into a research assistant rather than a report generator. First, read each record, extract relevant facts, and attach links for the doctor to verify. Two contradictory findings? Flag them. Missing imaging data leading to uncertainty? Flag it. Once fact-checking is done, a "generate report" button appears—the report is assembled from already-verified facts. This design allows each unit to be scored independently: Is this contradiction real? Does this citation support this claim? This Pattern Generalizes Ask these four questions: What do users actually need to check? What trusted references can they compare against? What signals or heuristics do experts use for verification? What smaller units can be accepted, edited, or rejected? A thread running through all examples is provenance. The fastest way to make output inspectable is to show where each piece came from, with links to details. Use progressive disclosure so these sources don't overwhelm the user. Even for products that seem "easy to evaluate" (e.g., you produce working code), the best products still make work more inspectable—Cursor and Devin both record short UI change videos so you can confirm correctness without replaying everything. None of This Is New These are old design principles—observing experts in their domain is called needfinding, and structured sensemaking in medical diagnosis is sensemaking. But before the AI era, verification typically happened incidentally during product creation. In the AI era, verification is the bottleneck. It's time to think about it more explicitly. Original: Hamel Husain, "'It's Hard to Eval' Is a Product Smell", 2026-06-29 https://hamel.dev/blog/posts/eval-smell/… #AIProduct #Eval #ProductDesign
Original Article
View Cached Full Text

Cached at: 07/06/26, 12:12 PM

This one, Hamel Husain – one of the most practice-savvy AI eval experts – said something: “It’s hard to eval” is a product smell. If you don’t give users checkable intermediate artifacts, they’ll redo your work to verify the output. What value does your product offer them then?

“It’s hard to eval” is a product smell

I’ve been working on AI evals for three years. The most common objection I hear is “our product is hard to eval.” That objection itself is a product smell – if it’s hard for you to verify, it’s hard for your users too.

More importantly: designing a product that is easy to verify should come before writing evals.

Example 1: AI data analysis agent

Almost every company is building an internal analysis agent. You ask a business question, it finds data sources, runs queries, and gives an answer. The goal is to reduce dependence on data analysts.

Most common mistake: making the “answer” the only output.

The interface shows only one number – “Product A net revenue last quarter: $4.21M.” The user has no way to verify except redoing everything. A better design is not to hide the process, but to give users checkable artifacts.

A data analyst verifying a metric does six things: cross-check intermediate calculations and totals against a trusted source; confirm the precise metric definition; sanity-check related quantities; break down aggregates by dimensions; read the SQL; note what couldn’t be verified.

A good AI data analysis agent should do the same – show sources, assumptions, and unverified items in the answer. The user can click to open a Notebook for the full analysis: the agent’s assumptions, the queries run, the decomposition by region, and an explicit list of “what couldn’t be verified,” each kept as a runnable cell so the user can dig deeper.

What this means for evals

If your product is designed for easy verification, annotation costs drop, and evals have better signals to draw from. More importantly, you’ll give users a better product.

Example 2: PE lesson plan generator

A founder’s product: a teacher enters constraints (grade, duration, indoor/outdoor, equipment), AI writes a lesson plan.

“How do you eval a lesson plan’s quality?” – Hamel turned the question around: what do teachers care about? The fastest way is to see “a plan that a teacher like you has already used.” A good design: instead of generating a plan from scratch, start from a vetted plan used at 14 schools, run 30+ times this year, then show only the changes – “shortened to 45 minutes, warm-up changed from 2 laps to 1, matched your equipment so 4 stations become 3.” The teacher doesn’t review an entire plan, but a diff – cognitive load greatly reduced. Evals also become more tractable: you only need to verify whether the retrieved plan is reasonable and whether each modification follows the constraints.

Example 3: Workers’ comp medical report

A product generates a 50-page expert opinion from medical records (MRI, PT notes, exam reports). Problem: the doctor is liable for the report, so they re-read all records and check every claim – taking as long as writing from scratch. No value.

Hamel advised making the product a research assistant rather than a report generator. First read each record, extract relevant facts, attach links for the doctor to verify. Two exam findings contradict? Flag it. Imaging missing leaves the current status uncertain? Flag it. After fact review, a “Generate Report” button appears – the report is assembled from already-verified facts.

This design allows each unit to be scored independently: is this contradiction real? Does this citation support this claim?

This pattern can be generalized

Ask these four questions: What does the user actually need to check? What can they compare against a trusted source? What signals or heuristics does an expert use for verification? What smaller units can be accepted, edited, or rejected?

A common thread through all examples is provenance. The fastest way to make output checkable is to show where each piece came from, with links to see details. Use progressive disclosure so these sources don’t overwhelm the user.

Even if a product seems “easy to evaluate” (like code that runs), the best products still make work more checkable – Cursor and Devin both record short UI change videos so you can confirm correctness without re-running.

None of this is new

These are old design principles – observing experts in their domain is called needfinding, structured understanding in medical diagnosis is called sensemaking. But in the pre-AI era, verification usually happened incidentally during the process of creating a product. In the AI era, verification is the bottleneck. It’s time to think about it more explicitly.

Original: Hamel Husain, “‘It’s Hard to Eval’ Is a Product Smell”, 2026-06-29 https://hamel.dev/blog/posts/eval-smell/

#AIproduct #Eval #ProductDesign

Similar Articles

@yibie: Recommending this article on AI product design by Geoffrey Litt (Design Engineer at Notion). He unearthed a striking claim from a 1992 talk by Mark Weiser: 33 years ago, people were already criticizing the "copilot" metaphor as the worst interface design for AI.

X AI KOLs Timeline

Recommends Geoffrey Litt's article criticizing the AI 'copilot' metaphor, advocating for a HUD (Heads-Up Display) design philosophy that makes AI a background awareness tool rather than a conversational assistant.

@feltanimalworld: Master, your post kept me pondering for two whole days! I originally wanted to write a long piece, but there were too many threads and I didn't know where to start. To sum it up, this is why I've been on Twitter lately—I felt something crucial was missing in my development understanding; it's also why, besides my hardware repair work, I've had to look into text-to-CAD recently. I...

X AI KOLs Timeline

The author discusses the lack of intermediate representation (IR) and verifier in the deployment of AI in serious industries, using text-to-CAD as an example to illustrate the key role of unified IR and verification in the feasibility of AI solutions.

@ba_niu80557: Let's talk some hardcore practical knowledge while I have time this morning. What actually happens between signing a contract for an AI project and it finally running in production? I'll lay out the entire playbook. People in this field can copy it directly, and those not in it can still understand why 95% of enterprise AI pilots end up dead. First, let me say something counterintuitive to the point you might not believe...

X AI KOLs Timeline

This article discusses common reasons for the failure of enterprise AI projects from proof-of-concept to production deployment, highlighting key practices such as MLOps, early inspection of real data, and clear human-machine boundaries. It argues that project failures are often not due to model issues but due to neglect of the engineering implementation phase.

@nash_su: A must-read—Jakob Nielsen (founder of Nielsen Norman Group and UX legend) on UX design in the AI era. I distilled his long-form insights into Chinese for easy reading; original link at the end. Many ideas he covers already pop up in great products, but no one has assembled them into a single dominant solution yet.

X AI KOLs Timeline

Jakob Nielsen’s deep dive into AI-era UX design, condensed into Chinese, spotlights concepts scattered across top products but not yet unified in one leading solution.