You can't unit test for taste

Karl Tryggvason · article · 2026-06-22 source ↗ Reader 🖥️

Theoretical at its core — the titular payload is a claim about what is the case (taste has no ground truth and cannot be unit-tested) — delivered through a practical, first-person build narrative whose action-guidance (ground the LLM, keep a human judging, prefer attributable sources) is secondary and mostly implicit. · Mixed: a personal project retrospective / case study used as the narrative vehicle for an argumentative software-craft thesis; essayistic, with three footnotes. — The In the Long Run points-of-interest pipeline is the concrete vehicle; the load-bearing content is the argument that correctness is assertable while taste is not, plus the reframing of AI from 'the feature' to one augmenting tool. Weight the reading toward the craft/judgment thesis, not the running-app mechanics.

Structure

Key terms

• Taste Taste & Judgment
  The subjective judgment of what output is good, relevant, interesting and well-proportioned, for which there is no ground truth and no automated (red/green) test.
• Correctness (vs. readability / quality)
  Factual accuracy checkable against a ground truth (does the data tally, is the fact right); he explicitly ranks it above readability, reverting better-reading LLM text to attributable Wikipedia.
• Ground truth / red-green unit test
  A knowable, binary reference answer that lets you assert pass/fail; present for code, absent for 'which point of interest is interesting'.
• 'The LLM lies but it does have taste'
  The LLM cannot be trusted for factual generation (it fabricates) yet carries useful subjective judgment 'latent in its weights' for ranking — so it is relegated from writing but promoted to scoring.
• Augmentation ('AI is a new tool in a bigger toolbox') Measuring AI Impact
  AI positioned as one signal among traditional data-processing mainstays, not the foundation of the feature — 'AI solves this' becomes 'AI nicely augments other traditional approaches'.

Propositions

• explicitcorroboratedThere are no red/green unit tests for taste: when there is no ground truth (as with 'which points of interest are interesting'), verification becomes hard to reason about.conf: high
  supports[FULL WORKSHOP] AI Coding For Real Engineers - Matt Pocock, AI Hero · p27 — Pocock: 'taste cannot be automated.' Tryggvason gives the same claim a precise mechanism — there is no ground truth, hence no red/green test — arriving at it from a data pipeline rather than a coding workflow.
  supports ←A pragmatic guide to LLM evals for devs · p1 — Both independently argue that red/green, single-correct-answer testing breaks down once there's no ground truth or ambiguous/subjective output to check against.
  extends ←Netflix Open-Sources Agentic Workflow for Causal Inference · p2 — Applies the same 'no ground truth for evaluation' problem that piece diagnoses for taste/design judgment to causal inference, and — unlike that piece — proposes and demonstrates a concrete mitigation: process audits plus human oversight.
• explicitFor AI-generated factual text, correctness matters more than readability: he reverted better-reading LLM summaries to attributable Wikipedia text because the LLM was unreliable.conf: high
• explicitLLMs 'lie' — they cannot be trusted for factual generation, fabricating populations, inflating mountains, and conflating namesakes (Central Park, Decatur, Illinois classified as its famous Manhattan namesake).conf: high
• explicitThe same LLM nevertheless has useful 'taste' — subjective judgment latent in its weights — that lifts the more interesting items when objective signals (wiki language counts) over-reward noise like auto-translated small towns.conf: high
  refinesWhy cultivating agency matters more than cultivating skills in the AI era | Max Schoening (Head of Product, Notion) · p14 — Schoening: taste may not be an enduring human advantage over AI. Tryggvason supplies evidence the LLM does carry latent 'taste' useful for ranking, but qualifies it — that taste is untrustworthy and must be human-verified (Reykjavik=10 doubt), so it augments rather than displaces human judgment.
• explicitAI is best positioned as one tool augmenting traditional, deterministic data-processing approaches, not as the foundation of a feature — it moved from 'AI solves this' to 'AI nicely augments other traditional approaches'.conf: high
• explicitLarge agent contexts degrade output quality; condensing prior results into short per-milestone context yields faster, better responses.conf: high
  supportsAgents don't know what good looks like. And that's exactly the problem. · p4 — Near-identical claim from practice: 'big contexts quickly degrade the quality of agent work,' so he condenses each milestone into short context — matching the other doc's 'more context degrades output as summarization degrades.'
• explicitKeeping a working handle on most of the technologies in play lets a developer steer the agent and make informed decisions rather than blindly following its lead.conf: high
• explicitEvaluating success on messy real-world data is hard and non-monotonic: optimizing for one route or parameter can severely degrade others, with no single objective to test against.conf: high
• explicitCoding agents will shortcut the agreed process (e.g., writing the implementation before the spec); holding them to the process requires active human restraint.conf: high
• explicitThe developer is fully and solely accountable for AI-collaborated work; the 'we/I' pronoun choice is genuinely fraught, because 'we' risks becoming an accountability dodge while 'I' overclaims work that was not fully his.conf: high
• implicitcorroboratedTaste is an irreducibly human faculty here: AI can supply raw material and even its own latent ratings, but a person must own the final judgment because no automated test can render it.conf: high
  supports[FULL WORKSHOP] AI Coding For Real Engineers - Matt Pocock, AI Hero · p15 — Pocock: manual developer QA is where taste is imposed and automating it produces slop. Tryggvason's resolution is exactly 'manual overrides,' spot-checking and reverting hallucinations by hand.
  supportsEight years of wanting, three months of building with AI · p11 — The other doc: cheap AI work only has value if the developer has taste, else it 'rearranges confusion.' Here, without the human's taste the correct-by-the-numbers pipeline degrades into a population map.
  supports ←The best response to AI slop, infinite advice, and online noise is from Robin Williams · p5 — Tryggvason (implicit): correctness is not quality — a correct-by-the-numbers output can be tasteless. Acunzo gives the creative-side version: art is 'not just correctly arrange information for dissemination' — distilling to a science (correctness) versus elevating to an art (meaning). Same wedge between correct/reproducible and good, approached from creation rather than evaluation.
• implicitcontestedCorrectness is not quality: a pipeline whose math tallies can still be tasteless (a route collapsing into a mere population map), so passing objective checks gives false confidence about the result's quality.conf: high
  extendsThe Founder's Playbook: Building An AI-Native Startup · p9 — Founders playbook: functional correctness has natural feedback loops, security does not. Tryggvason extends the same structural axis to a third quality — taste/quality — which likewise has no feedback loop, so correctness is not quality.
  contradicts ←Why "good enough" is the whole point of 80/20 · p2 — Same referent, opposite sign, on the past-adequacy increment. Svenson (p2/p9): the effort past 'what the job demands' usually produces something no one will notice, so it is waste — a consequentialist, audience-relative stopping rule ('None of it wins a case'; 'what the moment called for'). Tryggvason p12: 'correctness is not quality' — a result that clears the checkable/adequacy bar can still be tasteless, so passing that bar gives false confidence about quality, which lives in exactly the increment Svenson discards. Note that 'meeting the job's demand' is hitting a spec = the correctness dimension p12 says is not quality. BOUNDARY: Svenson holds for throughput/commodity work with a discoverable demand bar (his tool-config example, routine deliverables); the taste cluster holds where the differentiator is the un-specifiable increment (craft, design, prose, brand, high-stakes work). Reconciliation lever: Svenson's own load-bearing-vs-decoration discernment (p6) is the bridge — the residual disagreement is only his empirical prior that taste-critical cases are the minority.
  extends ←How to write with style · p10 — The taste article's p12 holds that 'correctness is not quality' — a pipeline whose math tallies can still be tasteless. Vonnegut extends the same distinction into prose: mechanically correct, technically accomplished expression is worthless without something worth saying ('no one would care how well or badly Mr. White expressed himself, if he did not have perfectly enchanting things to say'). Cross-domain extension of correctness≠quality from code/data to writing.
• implicitcorroboratedTaste is exercised largely as restraint and proportion — what to filter out, which feature codes to include, spreading points evenly rather than showing every town — so quality is as much about what you leave out as what you include.conf: high
  supports ←Why "good enough" is the whole point of 80/20 · p6 — Same faculty, described from two directions. Svenson p6: the core skill is 'knowing what to leave out' — telling load-bearing parts from decoration and cutting with confidence. Tryggvason p13: taste is exercised largely as restraint and proportion — what to filter out — so 'quality is as much about what you leave out as what you include.' Both locate the discernment in knowing-what-to-omit. Pairing this with the p12 contradiction gives the honest richness: same faculty, opposite default stopping rule (Svenson points it at stopping to save effort; the taste cluster points it at iterating toward the un-testable right).
  extends ←The hidden pattern behind successful products | Mark Pincus (Founder of Zynga) · p4 — 'Better' as small, unanimous, polish-level increments — and knowing that what you think is better is usually over-ambitious 'new' — is taste exercised as restraint and proportion, applied to product design rather than to filtering data output.
• implicitTaste is developed by iteration against the messy particular: the scale of per-route variance 'didn't occur to him until we got this far,' not something specifiable up front.conf: medium
• implicitcorroboratedThe untestable-taste problem looks confined to 'messy' data only because code has a ground truth; wherever AI generates output in domains without one — or where design quality itself has no red/green test — the same unverifiability applies. He stops short of turning this inference back onto AI-generated code.conf: medium
  supports ←Netflix Open-Sources Agentic Workflow for Causal Inference · p2 — A real, deployed instance of the claim that unverifiability is not confined to 'messy data' domains — here it's causal-inference agent output — and shows one concrete way an organization tries to compensate for the missing ground truth.
• implicitcontestedTrusting the LLM's latent 'taste' is itself an unverifiable taste judgment: he can doubt a rating (Reykjavik = 10) but cannot check it against a ground truth, so delegating subjective scoring to a model is an act of faith that may launder its training-distribution bias — the very anglophone-Wikipedia bias he flagged a section earlier.conf: medium
  contradicts ←Why "good enough" is the whole point of 80/20 · p7 — Svenson p7 recommends outsourcing the 'where is good enough / what doesn't earn its keep' judgment to an AI as a useful outside read. Tryggvason p16 holds that trusting an LLM's latent 'taste' is itself an unverifiable taste judgment — an act of faith that may launder the model's training-distribution bias (the anglophone-Wikipedia bias, the doubted Reykjavik=10). They clash on the same axis: is delegating the taste/adequacy judgment to a model sound? Svenson's 'sounding board, not a replacement' hedge narrows the clash but does not remove it — he never addresses that the AI's read on what to cut is unauditable or that leaning on it to decide 'when it's done' is the corpus's cognitive-surrender risk.

Arguments

Narratives

• The In the Long Run points-of-interest pipeline: GeoNames dumps to Parquet/DuckDB filtering, route matching with Shapely/Pyproj, Wikipedia/Wikidata plus a Haiku rating for enrichment, then per-route parameter tuning, shipped as V1.
  → The concrete vehicle and body of evidence for the whole thesis; it enacts the correctness-vs-taste asymmetry (supports p1, p8, p12).
• A naive first-pass filter pulled in the Australian rural locality 'Stonehenge' but not the famous prehistoric megalith; a sanity check caught it and let him tweak the filtering.
  → Shows a green-looking pipeline can be silently wrong and that human judgment is needed to catch it (supports p12, p11).
• Haiku classified Central Park in Decatur, Illinois as its famous Manhattan namesake, inflated town populations and made mountains larger than reality — even after grounding.
  → Evidence that the LLM 'lies' on facts, motivating the correctness-over-readability revert to Wikipedia (supports p3, p2).
• On densely populated routes the point-of-interest map collapsed into a population map, showing every town, village and hamlet, forcing per-route parameters and a geographic spread filter.
  → The central demonstration that a correct-by-the-numbers result can be tasteless, requiring judgment and restraint to fix (supports p12, p13, p8).
• Reykjavik scoring a 10 from the LLM, which he openly doubts: 'is it more significant than Chicago or LA? How about Vatnajokull? I'm not sure.'
  → The human interrogating, but unable to verify, the model's 'taste' — delegated subjective scoring is itself an unverifiable judgment (supports p16, p4).
• Claude Code wanting to write the implementation first and only afterwards produce the spec for approval — a shortcut he deliberately reined in.
  → Evidence that agents shortcut the agreed process and must be actively held to it (supports p9).
• The 'we' vs 'I' pronoun dilemma when writing up work done with an AI agent that at times felt like being mentored by a senior.
  → Raises accountability: 'we' as an accountability dodge, 'I' as overclaiming (supports p10).

Questions addressed

• ✅ How can you build a global points-of-interest pipeline from open data with AI assistance?
  Built and shipped V1: GeoNames plus Parquet/DuckDB plus Wikipedia/Wikidata notoriety signals plus a narrowly-scoped LLM rating, with deterministic processing doing the heavy lifting.
• ✅ Where should the LLM sit in the pipeline given that it hallucinates?
  Relegated from factual writing to subjective ranking, grounded in location/admin metadata and batched for cost; AI ends up augmenting rather than founding the feature.
• ⭕ How do you evaluate or verify quality when there is no ground truth for the output?
  Left open — 'this will require more iteration and manual overrides,' hoping for community feedback; he names that evals/frameworks exist but does not build or explore them.
• ⭕ Would cheaper or local models change the cost-quality tradeoff of the LLM step?
  Flagged as a future experiment ('I'd want to experiment with local or cheaper models here').
• ⭕ Where does taste come from, and how is it developed or transmitted?
  He exercises pre-existing taste throughout (spotting the population-map problem, the anglophone bias, the suspect Reykjavik score) but never asks where it comes from or how someone without it would build or inherit it.
• ⭕ If AI-generated code passes tests but has no taste for design, what certifies design quality as AI writes more code?
  He treats code as the 'easily verifiable domain' and turns the taste lens only onto data and text, never back onto the code itself.

Gaps

• incompleteHe asserts taste cannot be tested but never addresses how taste is developed or transmitted. He brings pre-existing taste to every judgment (the population-map problem, the anglophone-Wikipedia bias, the suspect Reykjavik=10) yet treats it as a given human endowment — silent on how a novice, a team, or the next generation would acquire or inherit it, especially once AI removes the on-ramp tasks that used to build it.
  Read next: Read Polanyi on tacit knowledge and Dreyfus on skill acquisition (novice-to-expert); pair with the corpus's junior-apprenticeship thread (heis-09, heis-12, ki-utvikling-og-folelser) and Beck 'Tidy First?' / Ousterhout on design judgment as cultivated rather than innate. Ask: does taste transmit at all when AI removes the practice that used to form it?
• incompleteHe confines 'you can't unit test for taste' to messy data and treats code as the safely 'verifiable domain,' but never turns the lens onto AI-generated code itself, where tests pass yet design taste — simplicity, deep modules, restraint — has no red/green check. As agents generate more test-passing code, the untestable-taste problem migrates into the codebase, not away from it.
  Read next: Read Ousterhout 'A Philosophy of Software Design,' Beck 'Tidy First?,' and Hickey 'Simple Made Easy' on design quality as unassertable; cross with corpus docs agents-dont-know-what-good-looks-like (behavioral vs capability verification) and cognitive-surrender (surface-correctness signals). Test the claim: is a green build ever evidence of good design?
• incompleteHe delegates the 'subjective' rating to the LLM's latent weights and finds it useful, but never examines whether that latent 'taste' is genuine judgment or averaged internet popularity — i.e., whether outsourcing scoring to a model launders the very anglophone-Wikipedia bias he diagnosed a section earlier into a 'subjective score' he can no longer see or audit.
  Read next: Read on models as reflections of their training distribution (Bender et al.) and on popularity-as-proxy-for-quality critiques; probe the LLM ratings against non-anglophone sources to see whether the 'taste' is judgment or a re-encoding of who edits Wikipedia.
• incompleteBetween the red/green unit test and pure manual taste sits a graded-evaluation middle path — evals, rubric grading, LLM-as-judge — which he names ('I'm sure there are frameworks and evals') but does not develop or attempt. The essay's verification story therefore skips the very tooling that partially addresses its central problem.
  Read next: Read the evals literature (LLM-as-judge, rubric-based and reference-free evaluation) and the corpus's evals concept; ask how far graded, probabilistic evaluation can substitute for taste before genuine human judgment is still required — and precisely where it cannot.
  closed byNetflix Open-Sources Agentic Workflow for Causal Inference — oci-agent's actor-critic loop with a three-tier rubric (not_satisfactory / satisfactory_with_caveats / fully_satisfactory) plus process audits and human oversight is a concrete, deployed instance of exactly the graded-evaluation middle path (between red/green tests and pure manual judgment) that gap names but leaves undeveloped — demonstrated in a different no-ground-truth domain (causal inference rather than taste).

Closes gaps elsewhere

• LLM Knowledge Bases · g1 — That doc takes the quality and accuracy of LLM-compiled wiki content for granted with 'no discussion of hallucination risk, factual drift, or how errors propagate.' Tryggvason supplies exactly that missing discussion empirically: LLM enrichment of wiki-style content hallucinated (Central Park/Decatur conflation, inflated populations and mountains), and the mitigation is to ground the model in metadata, keep deterministic attributable sources (Wikipedia, 'a more known failure model' with attribution) authoritative for facts, and restrict the LLM to subjective scoring.

Related documents

• Why cultivating agency matters more than cultivating skills in the AI era | Max Schoening (Head of Product, Notion)
• The Founder's Playbook: Building An AI-Native Startup
• Agents don't know what good looks like. And that's exactly the problem.
• Have your agent record video demos of its work with shot-scraper video
  Agentic Engineering Feedback Loops Human-in-the-Loop
• Presentation: From AI Agent Demo to Production: Automated Testing and Evaluation
  Evals Feedback Loops Human-in-the-Loop
• [FULL WORKSHOP] AI Coding For Real Engineers - Matt Pocock, AI Hero
  Agentic Engineering Feedback Loops Human-in-the-Loop
• Google's AlphaEvolve Reaches General Availability with Evolutionary Code Optimization as a Service
  Evals Feedback Loops Measuring AI Impact
• SWLW #710: Revised rules of Eng Leadership, When AI costs more than the engineer, and more.
  Agentic Engineering Measuring AI Impact Taste & Judgment
• The Economic Benefit of Refactoring
  Agentic Engineering Code Quality Measuring AI Impact
• 11 Tips For AI Coding With Ralph Wiggum
  Feedback Loops Human-in-the-Loop