Taste Compilation

What It Is

You look at two drafts and know which one works. You may not yet know how to explain the difference. If you correct the weaker draft and leave the explanation in a conversation, the next draft needs the same judgment again. If you save the example, name the problem and build a check for it, later work can use what you learned.

Taste compilation turns judgment into forms other people or processes can apply: rules, selected examples, mechanical checks and recorded rejections. It lets a system retain improvements across attempts. An uncaptured judgment helps one artifact and then disappears. A captured judgment applies to every artifact the system produces afterward.

Taste initially runs on one processor: you, examining one artifact at a time. A lint, grammar, collection of good examples or skill gives other processes a way to apply it. The cost changes from one unit of judgment per artifact forever to one unit once, followed by zero marginal judgment cost across ten parallel agents today and every agent that starts next year. The useful design question is how far one round of your judgment will reach.

Selection over Design establishes the advantage of sampling, selecting and promoting candidates, and describes the transition from building the process to maintaining it. Taste compilation explains how that selection accumulates: a verdict becomes language, then a mechanism that applies the verdict again. Intelligence Is Water approaches the same mechanism through constraints on generation. The language and constraints that guide a model are the result of previously captured judgments.

A closer look

From a verdict to a reusable standard

Some judgment remains with the person; the task is to preserve the parts that can guide or check later work.

Read this diagram

Notice a difference in quality → Name the distinction → Keep examples and rejections → Build a reusable check.

The Scarce Input

When models, agents and drafts are effectively free, producing candidates is no longer the expensive part. Knowing which of ten candidates is good, and why, remains expensive. That ability initially lives in one person.

The comparison with a generative adversarial network separates the generator from the discriminator. Taste is a learned discriminator over possible artifacts. You rent the generator, which improves on someone else's schedule; you own the accumulated distinctions used to judge its output. Under these conditions, the system's entire quality difference comes from its discriminator.

Trying to remove yourself from the process optimizes the wrong variable. Good automation spreads the benefit of your judgment over more work. One correction, once encoded, affects ten simultaneous artifacts and every later run. A rejection becomes a case study, a correction becomes a rule, and an insight becomes part of the skill future agents use. Feedback that stays in one conversation buys only one correction.

Will described why the manual work can produce exponential returns:

"Every time I do something, I can have AI replicate it across all the set… it amplifies to an exponential (if you know how)."

	Judgment burned	Judgment compiled
Where the feedback lands	Chat scrollback, working memory	Ledger, rule, golden example
Cost model	One unit per artifact, forever	One unit once, zero marginal after
What the next run inherits	Nothing — re-derive from scratch	Everything — the full accumulated gate
System behavior over time	Resets; same mistakes recur	Ratchets; the floor rises monotonically
Your trajectory	Permanent operator	Compounding director

His instruction for the system was:

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

The compiled system replays past judgment. It does not replace the source of new judgment. Novel reframings, final quality gates and the next idea about what the system could do remain deliberately unautomated. As Will put it: "The system is my taste made executable; I remain the source of new judgment." The machine amplifies this alpha signal; it does not originate it.

The retention relationship makes the cost explicit. Let $j$ be the judgment exerted per iteration and $c \in [0,1]$ the fraction captured. The system's minimum quality rises with $\sum c \cdot j$ , while the recurring burden remains proportional to $(1-c) \cdot j$ . At $c = 0$ , the craftsman exerts the full effort forever and the system's minimum quality never rises.

Recording a verdict when you make it changes the next iteration. Previously settled judgments become reusable, leaving your live attention for the part of the problem that is still new.

The Lifecycle: Judgment → Language → System

Taste passes through three stages. Each supplies something the next stage needs.

Stage	Form	What you can do	Example
1. Felt judgment	Pre-verbal reaction	Point: "this one's off," "that one's alive"	Watching two renders and knowing which is right before knowing why
2. Language	Named handles, rules, case studies	Say it, teach it, prompt with it	"Compulsive-teacher repetition," "scene grammar," "unjustified run"
3. System	Machinery: lints, components, verifiers, skills	Enforce it without being present	A pixel-diff gate; a ported component that makes off-brand pixels undrawable

In stage one, you can discriminate before you can explain. You can point to the good candidate or say another one feels wrong, but produce no usable account of why. Unless the judgment is captured, it changes only the artifact in front of you.

Whistling provides a familiar example of a standard you can use without describing it:

"How am I able to just know how to whistle a tune? The song felt ENCODED in me. That is the same thing as taste — a memory representation of senses and taste is possible, like an ideal goal image that is getting clearer and clearer."

You did not study the tune, yet you retain a representation against which each attempted note can be compared. Taste works the same way at this stage: an increasingly clear goal image can grade candidates before you can explain the grade.

In stage two, recurring judgments acquire names. A name lets otherwise scattered observations attach to the same concept:

"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."

Without a name, you keep noticing the flaw as if it were new. With one, examples accumulate for you and your agents. Once "scene grammar" names a concept, later observations about scene construction have somewhere to go. The language framework explains how this vocabulary changes what you can recognize and ask a generator to do.

In stage three, the named rule becomes an enforced constraint. A lint detects the error. A component embodies the approved example. A verifier checks the result whether you are present or not. Language still needs an interpreter who applies it; machinery enforces the encoded condition. This is structure over request applied to quality.

The order cannot be skipped. A verifier for a quality you cannot name checks nothing. A skill written before you have encountered the work records an imagined standard. If outputs are poor and you cannot explain why, you need more candidates to examine at stage one. If you can explain the problem but it keeps recurring, the language exists and still needs to become a constraint.

Vocabulary Through Selection, Not Specification

In advanced layout, visual style and voice, a generator can produce more than you can describe. You may recognize the desired result without possessing words for it beforehand. An initial description therefore leaves much of the target unspecified.

Generating candidates gives you something to judge. Repeated selection then reveals which distinctions need names. Will observed this while a frontier model produced layouts he had never managed to request:

"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 asked for candidates, responded with directions such as "more ambitious" or "that one's off," and watched what changed. Recurring successful patterns acquired names. Those names then worked as prompts because they referred to examples both parties had encountered.

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

The process also makes your own judgment easier to inspect. Will described it this way: "It's kind of beautiful, the metacognitive aspect — being able to witness and have the words to articulate my own intelligence."

The operational instruction is: "Where you have no words for the target, borrow the model's hands and mint the words from what they make." The sample-select-promote loop is promoting vocabulary as well as artifacts. Without that naming step, a successful output remains an accident you cannot reliably repeat. The loop also needs a budget: continually requesting candidates without choosing or naming anything becomes unbounded search.

Zhuangzi's wheelwright cannot put the feeling in his hands into words and therefore cannot teach his son. The usual reading is that tacit knowledge cannot be transmitted. But consider another way he could teach: keep a shelf of good wheels and a shelf of rejected ones, with annotations explaining the rejections.

He could not say it. But he could have pointed at it. A verbal specification cannot fully express his taste, while a collection of exhibits can define the standard by showing it. That is what a curated set of good examples supplies.

The Lockfile for Taste

The reusable unit is a versioned bundle of four parts: skill, golden set, verifier and rejection ledger. The lockfile pins them together, as a software lockfile pins exact dependency versions. Someone can then reproduce or fork the same standard of quality.

Each part has a distinct job. The skill gives instructions. The golden set shows what good means. The verifier checks whether the work meets the standard. The rejection ledger records the failures the system has already encountered. A skill without examples lacks the standard; without verification, quality returns to subjective impressions; without the ledger, failures are rediscovered.

Store and ship the whole bundle. The full lockfile account explains why distilled rules alone cannot preserve institutional memory, why rejection records stay verbatim, and how to measure readiness before running many agents in parallel.

The N=1 Case: The Sim Academy Pipeline

Will's Sim Academy pipeline produced animated explainers with Remotion, which renders video through React. From May through July 2026, its development passed through all three stages.

In early May, Will corrected individual videos by hand. Pacing was wrong, a value had been invented, or a transition broke visual continuity. Each correction improved one video and then stayed in chat scrollback. Every new video required his input again. This was the expensive architect phase before the system retained the decisions.

From mid-May through early June, those corrections became examples, rules and checks, first incidentally and then deliberately. A scene grammar changed the task from inventing each layout to mapping content onto a named archetype. That reduced variation between attempts. Porting the product's components verbatim made off-brand pixels impossible to draw, while pixel-diff verification let agents check their own work.

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

On June 10, ten parallel agents rebuilt the Academy video set. All 10 out of 10 passed verification, mostly on the first run. Will removed individual parts of the system to see which ones had produced that result:

Configuration	Result
Same model, no system	Every historical failure mode returns: unjustified runs, invented values, broken visual continuity
Better model alone	Raises the floor; does not produce the day's quality
Model + encoded-judgment layer (grammar, components, gates)	The measured biggest effect — first-run passes

The largest measured effect came from the layer containing his past judgments: grammar, components and gates. A better model helped, but did not produce the day's quality on its own.

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

In mid-June, access to the frontier model was revoked. Before losing it, Will had spent three days asking for "more interesting / more hype" and receiving good one-shot explainers. The weaker replacement model inherited the golden set, extracted patterns, and annotated positive and negative observations. Those records immediately improved its output: "Opus + the harness + my eye ships; it just doesn't soar."

During the gap, Will was "basically studying the work of a natural and codifying it to be more mechanically replicable." He examined which sequences of concepts and animation choices had carried the explanations, then converted those decisions into grammars and checks that could run without the original context.

On July 1, access returned. The model completed the entire video backlog in one shot for 30% of a usage quota.

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

The reference examples and constraints were already settled. The stronger model could use them immediately, making parallel production possible. Corrections made on earlier models continued to guide agents running on models that had not existed when the judgments were recorded.

Ideas Depreciate. Loops Compound.

An artifact reflects the capabilities of the model that produced it. As models change, the artifact loses value. A process that generates variants, observes them, promotes winners, prunes losers and encodes what it learned gains value through each retained iteration.

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

Depreciates	Compounds
The finished videos	The golden set they were selected into
The clever prompt that worked once	The named pattern extracted from why it worked
Access to the frontier model	The harness distilled from its traces
This week's output	The ledger of this week's rejections

Will described the mature loop as "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." He supplied a direction, then judged concrete results. His taste evaluated candidates instead of specifying every detail in advance.

The process also changed his response to deficiencies: "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 same questions apply to your daily process. Where does new evidence enter? Which results do you keep, and which do you reject? What records preserve those judgments? Where are you repeatedly arguing with a limitation instead of changing the process around it? Both a person and a pipeline can be examined as a loop whose capacity to improve determines future results.

This applies beyond model access. A collaborator can leave, a model can be weakened or revoked, and your own unusually productive period can end. Work whose value depends entirely on that access disappears with it. During a period of unusually strong performance, save the decisions and their reasons, not just the finished work. Distill them into a form a weaker system can execute.

Losing access then lowers the maximum quality you can reach without losing the minimum quality already captured. The next stronger model or collaborator also starts with those accumulated distinctions, as the July 1 episode demonstrated.

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

The compounding asset is the layer of recorded judgment. In AI work, it lets a practitioner accumulate something independent of a vendor's release schedule instead of competing only on access to the latest model.

Moat = Slope

Taste is often treated as a rare property of a particular person. A process can also accumulate it through repeated observations and corrections:

"People think taste is scarce — but they misinterpret that to be one human's taste. no, taste is a SYSTEM, and that information is built up from lots of reps and reality contact… the moat belongs to whoever runs the taste-manufacturing machine, not to a tasteful human."

The competitive advantage is the rate at which the process improves, rather than its current standard. That rate has three factors:

\text{slope} = \frac{\text{verdicts absorbed}}{\text{contact}} \times \frac{\text{contacts}}{\text{unit time}} \times \text{retention}

Verdicts absorbed per contact depend on whether judgments are recorded. Contacts per unit time depend on the frequency of contact with reality. Retention is the ratchet equation's $c$ . Each factor can be engineered so the system learns faster than an unaided person.

"If you break down taste mechanistically/computationally -> you find the implications of taste is the moat -> yes, i can build a system that absorbs more reality contact / taste verdicts per unit data -> my machine will have more taste. most people get stuck at the anthropocentric interpretation."

Eventually, reality can supply labels directly. A sale, churn or a pass/fail result arriving frequently enough can replace the human judgment that started the process. This ground-truth substitution removes the individual person's taste as the limit on improvement: the system can learn from the actual outcomes it is trying to produce. Human judgment starts the process, but should not cap what it can learn.

How Judgment Enters: From Dialogue to Pure Selection

Early judgment enters through conversation. You explain the desired overall result, shape the information architecture, correct errors and argue about choices. This is necessary while the vocabulary is still forming. It is also expensive: every correction needs an exchange, and much of the explanation is lost afterward.

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

An instruction lasts for one context window. Examples, grammar and quality gates carry a standard across later windows. As those accumulate, more of your judgment can enter as a simple decision to promote or prune. Will described that stage as "you're no longer talking in language — you have enough building blocks and golden patterns extracted... I just select and promote."

The verdict becomes cheaper because the machinery already contains distinctions you previously had to explain.

	Dialogue phase	Pure-selection phase
Judgment channel	Explanation, correction, argument	One-bit verdicts: promote / prune
Cost per unit of judgment	High — a conversation	Near zero — a glance
Where nuance lives	In your messages, dying with the context	In the bundle, permanent
What you are building	The language	The population
Exit condition	The handles hold; P(good \| ask) clears the bar	None — this is the compounding regime

That only continues if each selection updates the records. A promoted result goes into the golden set with its written reason. A rejected result goes into the ledger with the reason for rejection, verbatim. An unrecorded decision filters one batch but teaches the process nothing. Recording the decision lets later generations inherit it.

The records must also belong to the system you own. Golden sets, ledgers and verdict registries persist outside a vendor's context window. Larger context and retrieval-augmented generation provide rented cognition; they do not replace this owned state. As Will put it, "The body's memory limb is only alive if verdicts land in it."

Reviewing years of journals, disgust lists, taste notes and prose rules revealed an earlier version of the same process. Those records had been labeling a dataset before there was vocabulary to describe it that way. The accumulated verdicts formed a discriminator's training set.

In the mature process, the human supplies the initial judgments that can be copied into the bundle. Continued contact with reality drives further learning. Those first judgments point the process in a useful direction long enough for it to begin learning from outcomes.

Failure Modes

For each failure, examine where your last ten judgments went and what still retains them.

Failure mode	What broke	Signature
Judgment burned	Feedback given per-artifact, never captured	Same correction issued for the twentieth time; chat scrollback as the only record
Premature system	Stage three attempted before stage two	Verifiers checking qualities nobody can name; skills encoding fantasy taste; ten variants of garbage per fan-out
Naked skill	Skill shipped without golden set, verifier, ledger	Quality varies wildly across runs; "good" drifts; failures re-discovered monthly
Pipeline before reps	System designed for work never done by hand	The pipeline encodes your fantasy of the process; badness baked into automation where it's expensive to see
Automating yourself away	Optimizing for zero input instead of far-propagating input	The system plateaus at the taste it froze with; no source of new judgment remains
Readiness by vibe	Fan-out gated on excitement, not P(good \| ask)	Day-1 syndrome: "they all kind of look like shit," discovered after the batch
Dialogue forever	Judgment still entering as conversation after the handles hold	Re-explaining in chat what the bundle already encodes; leverage unused
Sanitized ledger	Rejections summarized instead of kept verbatim	The heat is gone; the ledger reads true but teaches nothing
Palate as ceiling	Reality's labels available but never wired into the loop	Human verdicts still gate everything; the system converges on your taste while reality grades something else

Building a pipeline before doing the work is particularly tempting. A single artifact can be judged today; a pipeline avoids that judgment until it runs. But doing the work reveals which steps need judgment, where quality actually comes from and what completion requires. Without those experiences, automation preserves an imagined process and makes its defects more expensive to discover.

Will caught himself doing this: "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." The difficulty underneath it was: "I want to make things good — like... I don't give things the time they need to be bad."

The early poor attempts supply the requirements for the eventual system. The June pipeline grew out of hand-built videos. The July 1 result also depended on a first shipped artifact made by hand, without the frontier model. That artifact gave the later vocabulary a concrete reference.

Running the Compiler

Do the work once by hand. Let the imperfect artifact reveal what the process needs before building the pipeline around it.
Record a rejection when it happens. Keep the actual words and their force. Feedback has to survive the artifact to improve later work.
Support all three stages. Give reactions a ledger, recurring judgments a name, and named rules a verifier, component or lint.
Develop vocabulary from outputs. When you cannot describe the target, generate candidates, judge them and name the recurring distinctions deliberately.
Version the complete bundle. Keep the skill, golden set, verifier and rejection ledger together as a lockfile that can be reproduced and forked.
Measure readiness before parallel production. Run ten candidates silently, score them against the gates and golden set, and inspect P(good | ask). Let that result determine whether to expand the run.
Capture unusually good work while access lasts. Save traces and decisions from a strong model, collaborator or your own best work. Set aside time to study and codify them.
Record every selection. Promotion updates the golden set; rejection updates the ledger. The judgment is cheapest to capture when you have just made it.
Keep a source of new judgment. Reuse settled judgments widely and reserve live attention for novel reframings and final gates. If nothing still needs your taste, the process has stopped learning.

These steps preserve the progression from a felt reaction to a rule another process can apply. Each new judgment still needs a way to enter, and each recorded judgment needs a way to affect later work.

Integration with the Mechanistic Framework

Connection to Selection over Design

Selection over Design establishes that selection beats design and names the architect-then-garden lifecycle. Taste compilation describes what the architect phase produces: a lockfile that turns judgments into language and enforced constraints. The maintenance phase accumulates improvements only when promotions update the golden set and rejections update the ledger.

Connection to Intelligence Is Water

Intelligence Is Water treats language and constraints as the design object. Grammars, components and verifiers reduce the possible outputs until bad results cannot be expressed. Taste compilation explains how judgments about actual outputs become those constraints.

Connection to Language Framework

The second stage is language acquisition through selection. Naming a recurring judgment activates pattern recognition and gives later observations a shared category. The vocabulary changes what the process can do.

Connection to Structure over Request

The third stage makes quality enforceable. A request alone cannot produce the required quality; verifiers, grammars and components constrain generation so it produces the result.

Connection to Accrual Substrate and Memory Is the Substrate

The ledger and golden set retain each verdict. The lockfile makes that persistent state part of the system itself: an individual skill execution ends, while its pinned examples, rules and history remain.

Connection to Skill Acquisition

Human learning turns explicit rules into felt fluency. Taste compilation moves in the other direction, making felt fluency explicit and reusable. The wheelwright had learned the craft internally but lacked this process for transmitting it.

Connection to Signal Theory and Compounding Artifacts

Judgment supplies the alpha signal in generation. Compilation amplifies it and retains it. The lockfile is the artifact that continues accumulating value through model changes, loss of access and time.