The Taste Layer: Codifying Human Judgment in Local AI Automation

The machine generates thirty marketing headlines in thirty seconds. That part is solved. The paid question — the one with a budget line and a job title attached — is which one ships. Thirty okay options, one right call: the difference between the two is everything AI vendors oversell and everything they can't sell you.

That difference has a name: taste. Not "good taste" as a personality trait, but taste as a professional competency — the ability to recognize good among many okay, say no to the rest, and put your name on the outcome. As automation takes over the floor (drafts, summaries, scans, reports), human value concentrates at the ceiling: the selection, the responsibility, the judgment call.

Here is what every operator eventually hits, though: "trust your gut" is not an operating strategy. A gut that lives only in your head doesn't scale, doesn't survive your vacation, and can't be inspected when the outcome goes wrong. The fix is the quiet superpower of a local AI stack: you can write your taste down — as rubrics, ban lists, and decision logs the machine enforces on every run, while you keep the one thing that can't be delegated: the responsibility.

What Taste Actually Is at Work

Strip the romance and professional taste has three working parts:

• Recognition — you've seen enough launches, campaigns, and failures to know which of the thirty headlines is the one. The model processed data about those events; you lived them.
• Refusal — knowing when to say no. The consultant who tells a client they don't need more marketing is practicing taste. A model, by design, always offers you more.
• Responsibility — "I chose this path and I own the outcome." No AI can be blamed in a way that matters. Accountability is the one input that never gets automated.

Notice the shape: taste is not the production of options. It is the filter and the signature on options. That's exactly the layer a well-built automation stack is missing by default — and exactly the layer you can build.

Why a Local Stack Makes Taste Codifiable

Any AI setup can nod at "human in the loop." The local-first stack makes it concrete, for three reasons:

1. Everything is a file. Your rubric, your ban list, your decision log — plain files you can read, version, and grep. Not settings buried in a vendor dashboard.
2. The judge can run on your standards privately. A local model applying your rubric to every draft means your taste works at 3 a.m. on output nobody showed you.
3. Privacy of the honest version. Decision logs that name real clients, real doubts, real mistakes ("passed on this because the founder's tone felt off") stay on your machine. Honest logs are useful logs.

Taste Artifact 1: The Rubric — "Good," Written Down

The rubric is your definition of good, stated plainly enough that a model can apply it as a judge. Start from what you already say out loud when reviewing drafts:

rubric: blog-post-review
standard: |
  A passing post: opens with a concrete scene or number, not a thesis;
  one idea per section; a reader can act on it tonight; no sentence
  that would survive on a competitor's blog untouched.
score_1_to_5:
  hook: "first line makes a specific claim or paints a specific moment"
  substance: "names tools, numbers, or steps — not adjectives"
  voice: "plain English, short sentences, zero corporate filler"
  ending: "an action or a consequence, not a summary of the essay"
fail_conditions:
  - any buzzword from the ban list
  - promises outcomes (views, revenue, guarantees)

Run it as a judge step in your pipeline — the same llm-rubric pattern from the eval world — and every draft arrives at your gate pre-scored against your standard. The first version of the rubric will be wrong in places. That's fine; a wrong rubric you can edit beats a perfect instinct nobody can inspect.

Taste Artifact 2: The Ban List — "Never," Written Down

Half of taste is knowing what you refuse. The ban list is the cheapest taste artifact and the most enforcement-ready:

{
  "never_ship": [
    "unlock the power of",
    "game-changer", "revolutionize", "seamless",
    "In today's fast-paced world",
    "delve", "tapestry", "testament to"
  ],
  "never_do": [
    "promise views, revenue, or guaranteed outcomes",
    "name Peak's former employer",
    "ship bad news on Friday afternoon"
  ]
}

The list does two jobs: the model screens it before anything reaches you, and — more importantly — writing it forces you to articulate refusals you've been carrying as vibes. Most people's "I know it when I see it" turns out to be twenty specific, checkable rules once they're pushed to write them down.

Taste Artifact 3: The Decision Log — Judgment With a Memory

Taste compounds when calls are recorded. One line per decision:

{
  "date": "2026-09-12",
  "call": "passed on headline variant B for the pricing page",
  "why": "the number hook implied a guarantee we can't stand behind",
  "reference": "similar call 2026-08-03 — held the line then too"
}

Three months in, this file is the most valuable document you own: your judgment, inspectable. Ask the local model to review it before the next big call — "here are my last twenty decisions on this kind of question; what's consistent, what contradicts?" You're no longer consulting a gut; you're consulting a corpus of your own judgment, and the model is the research assistant for your past self.

The Gate: Machine Produces, Human Commits

The artifacts feed one structural rule, the same one running through every mature workflow in this stack: the machine produces candidates; the human makes commitments.

Notice what automation did and didn't take. It took the 45 minutes of assembling options. It did not take the 4 minutes of deciding — and it cannot take the blame.

What Never Gets Codified

Honesty about the boundary keeps the system healthy. Some of taste stays human forever, and pretending otherwise produces confident nonsense:

The artifacts handle the floor of your taste. The ceiling — nuance, timing, reading the room, owning the outcome — is the part that was never automatable in the first place. That's not a gap in the system; that's the job description.

The Compounding Loop

The piece that turns this from hygiene into an advantage: your edits are training data. Every time you change a draft, diff your version against the machine's. The deltas — what you cut, what you kept, what you reordered — are your taste, expressed in the most precise language possible. Feed the recurring deltas back into the rubric and the ban list, and next month's drafts arrive closer to shippable. The machine doesn't learn your taste by magic; it learns because you wrote the deltas down. Six months of that loop, and people will describe your output as "having a voice" — without ever seeing the files that voice lives in.

Make It Practical This Week

• Write the ban list first — twenty minutes, immediately improves every output, teaches you what your taste actually refuses.
• Convert your last three editorial rants into rubric lines. If you can't state the rule, that's the rule you don't have yet.
• Start the decision log today; the value is in the accumulation, not any single entry.
• Add the gate to your highest-volume workflow if it doesn't have one — candidates in, your signature out.

The future of work isn't humans racing the machine at production. It's the machine producing endlessly while one rested, judgment-carrying human stands at the gate with a fork — and the files that make their taste stick.

Frequently Asked Questions

Isn't writing taste down just reducing it to rules that miss nuance? The rules don't replace nuance — they clear nuance's calendar. Every cliché the ban list catches and every structural flaw the rubric flags is a judgment call you no longer spend attention on, leaving it for the calls that genuinely need a human: timing, reading the room, taking responsibility. Codify the floor of your taste; keep the ceiling human.

How is this different from just proofreading AI output? Proofreading is inspection at the end, one output at a time, using only the taste in your head at that moment. The taste layer is infrastructure: the standards run automatically on every output, the gate is structural rather than habitual, and the decision log means every call makes the next one better. Same judgment, different leverage.

What if my rubric and my gut disagree on a specific draft? Log it, then trust the gut for the call — and afterwards, update whichever was wrong. If the gut wins repeatedly, the rubric is stale; if the rubric wins, your instinct was mood. Either way the disagreement is the most valuable data in the system, and it only exists because both sides were written down.

Does this apply if I'm not technical enough to build pipelines? The artifacts need no pipeline: a ban list and rubric work as a prompt you paste, and a decision log is a text file. The gate can be as low-tech as reviewing a folder of drafts every morning. Start manual, on one recurring workflow — when the habit sticks, that's the moment to wire it into n8n.