Taste Compilation

What It Is

Taste compilation is the practice of converting judgment — the felt sense that this output is good and that one is off — into executable form: named rules, curated exemplars, mechanical verifiers, recorded rejections. The underlying law: judgment is the scarce input to any generation system, and the system ratchets instead of resets only if that judgment is captured into a form something other than you can run. Uncaptured judgment is spent once, on one artifact, and evaporates. Compiled judgment applies to every artifact the system ever produces after it.

In computational terms: your taste is source code that currently runs on exactly one processor — you — one artifact at a time, with no persistence between runs. Compilation translates it into forms other processes can execute: a lint, a grammar, a golden set, a skill. The economics change completely. Interpreted taste costs one unit of judgment per artifact forever. Compiled taste costs one unit of judgment once, then executes at zero marginal cost across ten parallel agents today and every agent that boots next year. The design question for any generation system is therefore not "how little of me does it need?" but "how far does one round of me propagate?"

This article sits between two siblings. Selection over design establishes that selection wins — sample, select, promote beats designing the perfect thing — and names the two-phase lifecycle, architect-then-garden. This article is about how selection compounds: the mechanism by which raw verdicts ("good" / "shit") climb through language into machinery, and why that climb is the whole game. And Intelligence Is Water says the design object is the riverbed — the language and constraints that channel the flow. Same law, seen from the water side: the riverbed is compiled judgment. This article is about the compiler that produces riverbeds.

The Scarce Input

A generation system has one input that does not scale with compute: judgment. Generation is cheap and getting cheaper; models, agents, and drafts are effectively free. What remains expensive is knowing which of the ten candidates is good, and why — and that knowledge currently lives in exactly one place. So the naive automation goal — get yourself out of the loop — optimizes the wrong variable. The actual mechanism of good automation is the opposite: it does not remove you, it amortizes you. One round of judgment, once encoded, gets multiplied across ten artifacts simultaneously — and applies again on every run after that.

Amortization runs on a flywheel: feedback → rule → skill → every future agent. Every rejection becomes a case study. Every correction becomes a rule. Every insight becomes a section of the skill the agents execute. The correction IS the product — per-artifact feedback that isn't written down is judgment burned for one output.

Will's compression of the whole doctrine:

"Don't automate yourself away. Compile yourself, and let the compiler run everywhere at once."

Note what this does not claim. The compiled system never replaces the source of judgment — it replays past judgment. What stays unautomated stays unautomated by design: the novel reframes, the final quality gates, the next capability-first idea. As Will logged it: "The system is my taste made executable; I remain the source of new judgment." The compiler runs old verdicts everywhere at once; new verdicts still come from one place. This is the alpha signal economics of automation — the machine multiplies your signal, it does not generate it.

The ratchet condition can be stated as an inequality. Let $j$ be the judgment you exert per iteration and $c \in [0,1]$ the fraction of it that gets captured into the bundle. The system's floor after $n$ iterations rises with $\sum c \cdot j$; the operator's recurring burden stays proportional to $(1-c) \cdot j$. At $c = 0$ you are the classic craftsman: full effort forever, floor never moves. At $c$ near 1 the floor climbs every round and your live judgment migrates to the frontier of the problem — which is the only place it was ever irreplaceable. Nothing about this requires more talent. It requires that the write-down happen in the same breath as the verdict.

The Lifecycle: Judgment → Language → System

Taste is not a static possession. It moves through three stages, and the stages cannot be skipped.

Stage one is where you can discriminate long before you can articulate. You point at the good candidate; you say "this is off" about the bad one; asked why, you produce nothing usable. Most taste dies here — applied once to one artifact, then gone.

Stage two is where repeated pointing mints the words. The judgment gets a name: a coarse-grained handle, a rule, a case study. This step is not cosmetic. A word is a cognitive handle, and installing the handle changes what the machine underneath can do:

"You don't even need to teach a concept — if you teach the word, it gives the cognitive handle to that concept and it activates the pattern matching machinery in your brain."

The brain is an associative machine; a named concept becomes a node observations can attach to. Without the name, instances stay scattered — you re-notice the same flaw fresh every time. With the name, they aggregate, for you and for your agents: once "scene grammar" exists as a word, everything downstream starts collecting instances of it. This is the language framework operating at the scale of one workflow: the vocabulary you mint is the grammar your generation flows through.

Stage three is where the named thing grows teeth. The rule becomes a lint. The exemplar becomes a component. The judgment becomes a verifier that fires whether or not you are in the room. Language still requires an interpreter who cares; machinery does not. This is where structure over request takes over — you stop requesting the quality and build the topology that enforces it.

The ordering constraint is absolute: writing the system before the judgment has minted the vocabulary produces garbage, because the words have no referents yet. A verifier for a quality you cannot yet name checks nothing. A skill written from imagined taste encodes your fantasy of the standard, not the standard. Diagnose failures by stage: outputs are bad and you can't say why — you're at stage one and need more volume to point at. You can say why but the system keeps re-making the mistake — your language exists but hasn't been compiled into machinery.

Vocabulary Through Selection, Not Specification

Prompting orthodoxy says: figure out the words, then ask. In taste-heavy domains — advanced layout, visual style, voice — this fails structurally, because your descriptive range is smaller than the generator's range. You do not possess words for the target before seeing it; any upfront description underdetermines it. So the loop inverts: don't specify, then generate — generate, select, then name.

Will caught the mechanism live, logging why a frontier model was producing layout work he had never managed to prompt for:

"It's very hard to prompt the fancy things it's doing in the layout, so it's like I'm just generating very coarse-grained linguistic handles by having the model's natural visual intelligence be pushed further and further."

He never specified the behavior. He fanned out candidates, pointed directionally ("more ambitious," "that one's off"), watched what came back, and compressed the recurring goodness into handles. Then the handles worked as prompts — because now the words had referents. The compression:

"The vocabulary is the output of the process, not its input."

There is a strange recursion in the harvest step worth naming: the process generates words for judgments you were already making but could not see. "It's kind of beautiful, the metacognitive aspect — being able to witness and have the words to articulate my own intelligence." Compilation is not only how taste scales; it is how taste becomes visible to its owner.

And the operational rule: "Where you have no words for the target, borrow the model's hands and mint the words from what they make." This is language acquisition through selection pressure — the same sample-select-promote loop, but what gets promoted is words. The naming step is what converts a one-off workflow trick into reusable doctrine; skip it and the good output remains an accident you cannot repeat. Note that this only converges under a budget — pointing at candidates forever without compressing is unbounded search, paying to avoid selecting.

There is a quiet philosophical payoff here. The wiki's oldest parable — Zhuangzi's wheelwright, who cannot put the feeling in his hands into words and so cannot teach his own son — is usually read as proof that tacit knowledge cannot be transmitted. Taste compilation qualifies the verdict: the wheelwright's export format was specification, and specification is exactly the channel that fails. He could not say it. But he could have pointed at it — a shelf of golden wheels and a shelf of rejected ones, with the rejections annotated. Taste can't be fully specified in words; it can be defined ostensively, by exhibits. That is the loophole the golden set exploits.

The Lockfile for Taste

If the lifecycle describes how judgment climbs, the lockfile describes what it compiles into. The reusable unit of value in a generation system is not the prompt, not the model, not any artifact. It is a bundle of four pieces, versioned as one unit:

Will calls this a lockfile for taste, on analogy with a software lockfile that pins exact dependency versions: it pins exactly what "good" means at this moment, reproducibly. And it is forkable — someone else can take the bundle, re-converge the golden set against their own judgment, and inherit the grammar and verifier for free.

Forkability is the under-appreciated property. Taste transfer between people has historically been apprenticeship — years of co-located pointing, the only channel the wheelwright had and the one his son never completed. A versioned bundle changes the transfer economics: the grammar and verifier move losslessly, and only the golden set needs re-convergence against the recipient's own judgment. The apprenticeship compresses to the part that was actually personal.

The rule that follows: never ship or store a skill alone. A skill file without its golden set is instructions without taste. Without its verifier, quality is unenforceable. Without its ledger, the system has amnesia about its own failures. Version the four together so the definition of "good" evolves as one coherent object. The ledger deserves special defense against tidiness: keep rejections verbatim. "This felt cheap and lazy" carries information that a sanitized "insufficient polish" destroys — the heat of the original reaction is part of the data. The ledger is an accrual substrate in miniature, and the whole bundle is memory as the system: the skill is a temporary execution; the pinned taste is the persistent state that actually constitutes the pipeline.

One instrument is still missing from most bundles, including Will's early ones: a readiness meter. "Am I ready to fan out?" is a measurement, not a vibe — silently run ten candidates, score them against the gates and the golden set, and report P(good | ask). His own day-1 failure — "they all kind of look like shit" — was exactly this number sitting at roughly 0/10, unmeasured. Fanning out at P ≈ 0 produces ten variants of garbage; the meter tells you whether the language holds before you spend the batch.

The N=1 Case: The Sim Academy Pipeline

The load-bearing case study runs May through July 2026 — Will's animated explainer-video pipeline at Sim, built on Remotion (React-rendered video), and it traverses the entire lifecycle.

Early May: stage one, judgment burned. Hand-fighting individual videos, one at a time. Every correction — this pacing is off, this value is invented, this transition breaks continuity — spent on one artifact and lost to chat scrollback. Better videos required his input every single time, and the input evaporated after each use. This is the architect phase before capture: expensive, and structurally incapable of compounding.

Mid-May through early June: stages two and three. The fights got converted — at first mostly unknowingly, then deliberately — into golden examples, grammar rules, and gates. A scene grammar emerged that changed the type of the design problem: instead of inventing each scene layout (high variance), agents map the content onto a named archetype (low variance). Product components were ported verbatim, making off-brand pixels literally undrawable — a constraint at the riverbed level, where bad microstates become inexpressible rather than merely discouraged. Pixel-diff verification let agents self-certify. As Will compressed the last piece:

"Automation isn't agents being careful — it's agents being checkable."

June 10: the harvest, and the ablation. Ten parallel agents rebuilt the Academy video set; 10 out of 10 passed verification, mostly first-run. Will then did the honest thing and ran ablations to find out why that day worked — remove layers, watch what breaks:

The conclusion was not "the model got good." It was that the compiled layer carried the day, and the compiled layer was nothing but his own past corrections, made permanent. His log:

"Better videos came from more of my input, but the mechanism is that my input no longer evaporates after each video."

Mid-June: the natural experiment. Access to the frontier model that had made the pipeline feel magical — three days of "more interesting / more hype" producing genuinely good one-shot explainers — was revoked. Will dropped to a weaker model. What survived the revocation was not any video: it was the golden set, the extracted patterns, the annotated positive and negative observations. That compiled layer immediately lifted the weaker model — "Opus + the harness + my eye ships; it just doesn't soar." He spent the gap "basically studying the work of a natural and codifying it to be more mechanically replicable": reverse-engineering the frontier traces — which concept flows it chose, which animation choices carried the explanation — into harnesses and grammars that boot cold.

July 1: the payoff. Access returned, and the model one-shotted the entire video backlog for 30% of a usage quota. Not magic:

"The one-shot capability wasn't magic — it was prior convergence returning as leverage."

A converged reference plus a strong model equals fan-out capability. The compiled harness was waiting; the returning frontier flowed straight through it. The whole arc is the flywheel visible at full length: fights → rules → skill → every future agent, including agents running on models that did not exist when the judgment was minted.

Ideas Depreciate. Loops Compound.

The revocation episode carries the investment corollary, and it reorders where effort should go. Every artifact the pipeline produced is stamped with the capabilities of the model that made it; when the model churns, the artifact's value decays with it. But the loop — generate variants → observe → promote winners → prune losers → codify to reduce degrees of freedom → repeat — appreciates, because every iteration deposits something into it. Will's realization, verbatim:

"It's no longer about the quality of the idea but the quality of the loop, the daily algorithm, the procedure."

The week that crystallized it ran on the mature form of the loop: "increase ambition vaguely, let the agent decide what that meant, watch the end product videos that got produced, and then promote the winners and prune the losers." Vague ambition upward, concrete selection downward, taste entering as a fitness function rather than a blueprint — and, critically, "often times it's no longer out of conscious design — it's just noticing what works and promoting those patterns and discarding what doesn't and building solutions around deficiencies rather than being stubborn."

The corollary points back at you: analyze your own daily algorithm the way you would analyze an agent loop. Where does signal enter? What gets promoted? What gets pruned? Where is judgment being captured, and where is it being burned? Where are you being stubborn about a deficiency instead of building a solution around it? The person and the pipeline are the same kind of object under this lens — a loop whose quality, not whose latest output, determines what next year looks like.

The frontier lesson generalizes past models. Frontier access is a spigot, not a possession — models get nerfed and revoked, collaborators leave, peak states pass. Anything whose value lives only in live access evaporates with the access. So when you have superior intelligence on tap — a frontier model, a rare collaborator, your own best week — the highest-leverage move is to capture its exhaust: the traces, the decisions, the why behind each choice, distilled into structure a weaker system can execute. Then losing access costs you the ceiling, not the floor, and the distilled language makes the next frontier more effective the moment it arrives — that is exactly what July 1 demonstrated.

"The frontier is rented. What you distill from it is owned."

This is compounding artifacts with the compounding object identified precisely: not the outputs, the compiled judgment layer. And it is effective AI usage at its endgame — the practitioners who depend on frontier access compete on access; the ones who distill build an asset independent of any vendor's release schedule.

How Judgment Enters: From Dialogue to Pure Selection

The compiler changes the channel through which your judgment enters the system as the bundle matures. Early on, judgment enters as dialogue: you talk with the generator, shaping macrostates and information architecture in language, explaining, correcting, arguing. This phase is unavoidable — the vocabulary is still being minted, and conversation is the minting floor. But it is also the low-leverage phase: dialogue is judgment at its most expensive, one exchange per correction, and most of it leaks. The reason you cannot stay here is structural:

"Prompts transfer instructions; they don't transfer taste."

An instruction survives one context window. Taste — compiled into golden examples, grammar, gates — survives every context window that follows. So the mature phase looks completely different: judgment enters as pure selection, one bit at a time. In Will's description of the pipeline's late state: "you're no longer talking in language — you have enough building blocks and golden patterns extracted... I just select and promote." The verdicts got cheaper precisely because everything the verdicts used to have to explain is now in the machinery.

The transition has one non-negotiable discipline: write-back. In garden mode, a promote that does not update the golden set and a prune that does not update the ledger are wasted selection events — you paid the judgment and captured nothing, which quietly reverts the system to the burned-judgment column. Selection without write-back is filtering; selection with write-back is evolution. The write-back is the entire difference, and it is a two-line habit: winner goes in the golden set with its written why; loser goes in the ledger with its axis of failure, verbatim.

Failure Modes

Every row below is the same break seen from a different angle: judgment exerted somewhere the flywheel cannot reach. The diagnostic question for all of them — where did the last ten units of my judgment go, and what still holds them?

The pipeline-before-reps row deserves its own paragraph, because it is the builder's seductive form of procrastination: a pipeline can't be wrong until it runs, while one artifact can be wrong today. Every real process has texture that only shows up in the doing — which steps need judgment, where quality actually lives, what "done" feels like. Will caught himself in it directly: "let me just pause the optimization mind... let me just write out like one article. Maybe then two articles and then figure out the pipeline." And underneath, the honest root: "I want to make things good — like... I don't give things the time they need to be bad." First reps are structurally bad, and that bad output is the requirements document for the eventual system. The June pipeline's success traced back through hand-built videos; the July 1 one-shot explicitly required a first shipped artifact made by hand, without the frontier model — the seed referent everything else got named against.

Running the Compiler

1. Do the work once, by hand, badly. Before any pipeline. The first artifact is the requirements document, and the seed referent the vocabulary gets minted against.
2. Write the rejection down the moment it happens. Verbatim, with its heat. The correction is the product; feedback that outlives the artifact is the entire difference between ratcheting and resetting.
3. Instrument all three stages. Give felt judgments somewhere to land (a ledger). Give recurring judgments names (handles). Give named judgments teeth (verifiers, components, lints).
4. Mint vocabulary from outputs, not intentions. Where your words underdetermine the target, generate volume, point directionally, and compress what recurs into handles. Harvest the naming deliberately — it is the step that converts a trick into doctrine.
5. Version the bundle, never the skill alone. Skill + golden set + verifier + rejection ledger, as one object. That is the unit that is reproducible, forkable, and worth anything.
6. Measure readiness before fanning out. Run ten candidates silently, score against gates and golden set, read P(good | ask). Fan out when the number says so, not when the excitement does.
7. Distill every frontier while you have it. Save traces, not just outputs, of every unusually good run — model, collaborator, or your own peak state. Budget explicit time to study and codify the best outputs instead of only generating more.
8. Enforce write-back on every selection event. A promote updates the golden set; a prune updates the ledger. No exceptions — an unrecorded verdict is judgment burned at the exact moment it was cheapest to save.
9. Keep yourself as the source of new judgment. Audit what you've automated: replayed judgment should be everywhere, live judgment reserved for novel reframes and final gates. If nothing in the loop still requires your taste, the system has stopped learning.

The invariant across all nine: the system is a taste-preservation pipeline — an escalator that carries felt reactions up into executable constraints. Your job is to keep feeding the bottom and to keep the escalator running.

Integration with the Mechanistic Framework

Connection to Selection over Design

That article proves selection beats design and names architect-then-garden. This article is the compiler inside it: what architect mode actually produces (the lockfile), how verdicts become language becomes machinery, and why the garden ratchets only if promotes update the golden set and prunes update the ledger.

Connection to Intelligence Is Water

The riverbed thesis — language as the design object, ratchets collapsing microstate space — is this law seen from the water side. Compiled taste is the riverbed: grammars, components, and verifiers are the terrain that makes bad outputs inexpressible. Taste compilation is how riverbeds get built from raw flow.

Connection to Language Framework

Stage two of the lifecycle is language acquisition under selection pressure, and the handle mechanism — naming activates the pattern-matching machinery — is why minting words is an engineering act, not decoration.

Connection to Structure over Request

Stage three is that article's enforcement layer: you cannot request quality from a generator, only build the topology that produces it. Verifiers, grammars, and ported components are where compiled judgment stops being suggestion and becomes structure.

Connection to Accrual Substrate and Memory Is the Substrate

The rejection ledger and golden set are accrual substrates: every verdict visibly deposits. And the lockfile is the substrate-as-system claim made concrete — the skill is a temporary execution; the pinned, versioned taste is the persistent state that actually constitutes the pipeline.

Connection to Skill Acquisition

The lifecycle is skill acquisition run in reverse direction: human learning internalizes explicit rules into felt fluency; taste compilation externalizes felt fluency into explicit rules. Same ladder, opposite traversal — which is why the wheelwright, who only climbed downward, could not teach his son.

Connection to Signal Theory and Compounding Artifacts

Judgment is the alpha signal in any generation loop; compilation is signal amplification with memory. And the lockfile is the compounding artifact par excellence — the deposit that survives model churn, access revocation, and time.

See Also

• Selection over Design — the parent algorithm; this article is its compounding mechanism
• Intelligence Is Water — the riverbed this compiler produces
• Language Framework — why minted vocabulary is machinery, not decoration
• Structure over Request — where compiled judgment gets enforced
• Accrual Substrate — the ledger as a substrate where every verdict deposits
• Memory Is the Substrate — the lockfile as persistent state constituting the system
• Compounding Artifacts — what survives model churn and why
• Skill Acquisition — the same ladder, traversed in the opposite direction
• Signal Theory — judgment as the alpha input the system amplifies
• Bounded Search — why the naming loop needs a budget to converge
• Effective AI Usage — distillation as the endgame posture toward rented frontiers
• Experience Extraction — the general reflex of converting events into reusable structure

Core Principle: Judgment is the scarce input to any generation system, and the system ratchets instead of resets only if judgment is captured into executable form. Taste moves through a lifecycle that cannot be skipped — felt judgment mints language through repeated selection, and language compiles into machinery — so generate, select, then name; the vocabulary is the output of the process, not its input. Version the four-piece bundle (skill, golden set, verifier, rejection ledger) as one lockfile for taste, and never ship a skill alone. Ideas depreciate with the model that made them; the loop compounds, because every iteration deposits. The frontier is rented; what you compile from it is owned.

The wheelwright couldn't say it, so it died with his hands. You can't say it either — but you can point at it, pin it, and let it gate every wheel the shop ever makes. Compile yourself, and let the compiler run everywhere at once.