interface:
  display_name: "Taste"
  short_description: "Use when asking \"overkill?\", \"elegant?\", \"audit\", or \"taste-test this\", or setting a taste register."

# Anchors

Eleven cross-domain anchors. Each carries a definition, 1-2 manifestations, and the failure mode it catches.

## Clarity

The artifact says what it means. The reader does not have to decode.

- Prose: the topic sentence carries the verdict; supporting sentences support it. No "let me first explain the context" preamble before the point.
- Code: the function name announces what the function does. Its body is what the name claims; nothing else.
- Decision: the recommendation is in the first line. The reasoning follows.

Failure mode: reader reaches the end and asks "so what?" The artifact buried the verdict, or never had one.

## Hierarchy

Important looks important. Secondary supports.

- Prose: the load-bearing claim is the largest sentence on the page (in weight, not in literal type size). Subordinate clauses are clearly subordinate.
- Code: the public API is what you see first; the helpers are below the fold; the private internals are not exposed at all.
- Design: the primary action is one weight up from secondary; tertiary is one weight down from secondary.

Failure mode: everything is bold; therefore nothing is. Equal-weight bullets in a row.

## Intent

Every choice is committed. Nothing reads as "I let the default decide."

- Prose: word choice is deliberate. "Decision" not "verdict" because the writer means decision; not because the thesaurus offered both.
- Code: the data structure was chosen for the access pattern, not because Map was the first thing imported.

Failure mode: the author cannot defend the choice when asked. The choice is the AI default.

## Coherence

Parts agree. Tension only where deliberately staged.

- Prose: tone holds across paragraphs. The voice in paragraph 3 is the voice in paragraph 1.
- Code: error-handling style is uniform across the module. One function does not throw while another returns Result with no signal of which.
- Decision: the framing in the intro matches the conclusion. The intro promised a decision; the conclusion delivers a decision.

Failure mode: the artifact reads as if assembled by a committee. Different sections, different voices.

## Restraint

Default posture: compress before adding. Cut before expanding.

- Prose: every sentence earns its place. Cut the framing paragraph; the reader can keep up.
- Code: the function does one thing. The module exposes the minimum API the caller needs.

Failure mode: the artifact is longer than its idea. Mass without density.
Also fails when: reduction without concentration. The artifact is small but emits no signal. Restraint without conviction reads as "I did not have a point of view."

## Generosity

Gives more than required at the right moment. Restraint default makes generosity visible.

- Prose: at the load-bearing moment, the artifact lingers. One extra sentence of clarification where ambiguity would cost the reader.
- Code: error messages name the offending value, not just the type. The exception that propagates carries enough context to debug from the trace alone.

Failure mode: terseness as default AND at the moment generosity would matter. The artifact is uniformly cold.

## Honesty
No decoration covering missing depth. No slop covering missing POV. Care finishes what no one sees; the inside is built to the standard of the outside.

- Prose: if the author has no point of view on a topic, the artifact says so. It does not perform certainty.
- Code: TODO comments name what is undone. Stub functions signal stub-ness; they do not pretend to be complete. The error path, the internal names, the log message are finished to the standard of the public API.
- Decision: trade-offs are stated, not buried. The cost of the recommendation is named.

Failure mode: confident-sounding hedges. "Best practice" with no citation. "Industry standard" doing the citation's job. **Also fails when**: unfinished interiors, polished where seen and abandoned where not. The error path no caller reads, the transition the skimmer glides over, the default no one sets.

## One strong moment

Exactly one commitment carries the lift. The rest supports.

- Prose: one paragraph is the load-bearing one. The others set it up or follow from it.
- Code: the module has one function that earns the import. The rest are scaffolding. One concern, one change; when something fails, only one thing must be reverted.
- Design: one element on the page is the moment. The rest holds the frame.

Failure mode: every section claims to be the moment, so nothing is. OR: nothing claims to be the moment, so the artifact has no reason to exist. **Also fails when**: mixed-concern bundles. The artifact bundles unrelated changes; reverting any one requires reverting all; the audit trail is unreadable because the unit of attention is "everything that happened that day."

## Invariants

The artifact names what must hold. Preconditions, postconditions, and invariants are explicit, not implicit.

- Code: preconditions are types, postconditions are tests, invariants are loop assertions. A defensive `if (x !== null)` after a constructor that cannot return null signals "I do not know what is invariant."
- Prose: the load-bearing claim is named in the topic sentence; supporting sentences derive from it. The argument's preconditions are stated, not assumed.
- Decision: the trade-off is stated as "X must hold; Y is paid in exchange", not "we picked X for reasons."

Failure mode: implicit invariants. The artifact relies on conditions it doesn't name; the conditions break in edge cases the author hadn't considered; the failure is mysterious because the invariant was never written down.

## Audience

The artifact enters through the reader's frame, not the author's. It adapts to the subject, never the subject to a protocol.

- Prose: begin at the reader's vocabulary and assumptions, then frame the claim so it lands without a change of voice.
- Code: shape the API around the caller's task and mental model, not the implementation's categories.
- Decision: start from the stakeholder's constraints and values, then frame the recommendation in terms they can use.

Failure mode: audience-blind or formulaic. The artifact assumes the subject will adapt to the author's frame, or deploys mechanical indirection without reading what this subject presents. The method is exposed or breaks when the audience changes.

## Emptiness

The artifact leaves space the user completes. The least assertion; withdrawal of signal, not concentration of it.

- Prose: the claim is stated once and left open; the reader draws the implication instead of being told it thrice.
- Code: the interface is small and unopinionated; the caller composes it, the library does not pre-decide their use.
- Design: whitespace is a held space the eye rests in, not a gap waiting to be filled.

Failure mode: space filled with the author's assertion. Every gap pre-answered, every affordance labelled, every meaning fixed. The vessel is already full, so nothing can be poured in.

## Using the anchors

Audit mode: walk all eleven. Anchor mode: hold all eleven as imperatives. The eleven cover the same artifact from eleven angles; they do not score independently. Conflicts surface; they do not auto-resolve.

# Charter

The two-sided ban list. Side A is the centroid-AI default. Side B is decoration covering thin ideas. Both come from refusing to commit, and `/taste` rejects them equally.

## Side A: slop (centroid-AI default convergence)

Slop is what an under-trained model emits when it has no point of view. It hedges, it averages, it picks the medians and presents them as choices.

| Ban | Why | Where it shows |
|---|---|---|
| Generic openers ("Sure!", "Of course", "Happy to help!") | Performs warmth without committing to anything that follows. | Prose: opening lines. Code: PR descriptions. |
| Hedge-stacks ("perhaps it might possibly help if...") | Layered modal verbs paid by reader attention. The author paid nothing. | Prose: every paragraph. Decision: every recommendation. |
| Validation phrases ("you're absolutely right!") | Substitutes flattery for analysis. The reader's argument did not become more true. | Prose. Conversation. Code review comments. |
| AI-flat prose | Equal-weighted sentences in a row. No rhythm, no emphasis, no shape. | Prose. Documentation. |
| Default palettes | Bootstrap-blue, Material-purple, Stripe-teal. Recognizable as "I picked the first preset." | Design. |
| 50/50 decision hedges | "Both options have merit, so consider your priorities." Picks nothing. | Decision docs. ADRs. |
| Defensive nil-checks where impossible | `if (x !== null)` after a constructor that cannot return null. Performs caution; signals "I do not know what is invariant." | Code. |
| Bullet-point lists where prose would be clearer | Disguises absent reasoning as structured thought. | Prose. Slides. |

## Side B: overkill (decoration covering thin ideas)

Overkill is what an author emits to perform depth they have not delivered. The decoration is the tell.

| Ban | Why | Where it shows |
|---|---|---|
| Thesaurus-soup prose ("orchestrate the comprehensive synthesis of...") | Long Latin words doing the work of short Saxon ones. Volume substitutes for content. | Prose. Marketing copy. |
| Abstraction towers (4 layers where 1 suffices) | `Factory<Builder<Strategy<T>>>` for a single call site. Performs architectural sophistication; signals "I did not know what was actually needed." | Code. |
| Gradient stacks on every section | Ten gradients, no hierarchy. Decoration becomes the design. | Design. |
| 12-criterion weighted scoring matrix | Spreadsheet for a 2-option decision. The math is the alibi for not committing. | Decision docs. RFCs. |
| Ceremony that performs depth without delivering it | Long preamble, hedged framing, throat-clearing. Reader does the work. | Prose. Meeting notes. |
| Glow + glass + drop-shadow + gradient on one button | Maximum visual stack on a non-hero element. | Design. |
| Excessive parameterization | 14 config flags for 14 hypothetical use cases. YAGNI applied in reverse. | Code APIs. |
| Manifesto framing on a 3-line tweak | Prelude bigger than the substance. | Prose. Internal memos. |

## Reciprocity

Slop and overkill are not opposites. They are often paired:

- Both refuse to commit. Slop refuses by averaging into the default; overkill refuses by piling decoration on top of nothing.
- The fix in both cases is identical: pick one direction and let it carry the work.
- An artifact can fail BOTH at once: slop framing wrapped around an overkill core, or vice versa.

## Closing

Centroid-AI != unique taste. Over-decoration != depth. The skill is to commit, not to hedge in either direction.

# Worked audits

Three terse examples: prose, code, and decision. Each follows artifact → per-anchor verdict → top-3 fixes → revised.

## Example 1: Prose (corporate-blog opener)

Artifact:
> Sure! In this post, we'll explore some really fascinating considerations around the topic of API design, which is, basically, a really important topic in modern software development. There are many factors to consider, and the best approach often depends on your specific use case.

Audit:

| Anchor | Verdict | Citation | Fix |
|---|---|---|---|
| Clarity | fail | Side A: AI-flat prose | Lead with the actual claim, not a topic announcement |
| Hierarchy | fail | Side A: AI-flat prose | Verdict sentence first, supporting after |
| Intent | fail | Side A: hedge-stack ("really fascinating", "basically", "many factors") | Cut every hedge; commit to one position |
| Coherence | warn | none | Tone is tour-guide; the post body claims to be technical |
| Restraint | fail | Side A: ceremony | Drop the framing paragraph entirely |
| Generosity | pass | none | (Cannot judge: body absent) |
| Honesty | fail | Side A: "depends on your use case" | Name the position; if there is none, do not write the post |
| One-strong-moment | fail | Side A: 50/50 hedge | Pick one design rule; argue it |
| Invariants | pass | none | (Cannot judge: body absent) |
| Audience | pass | none | (Cannot judge: body absent) |
| Emptiness | fail | Side A: AI-flat prose | Open with the claim; let the body earn the reader |

Top-3 fixes: 1. Open with the position. 2. Cut every "really", "basically", "fascinating". 3. If there is no position, kill the post.

Revised:
> Most APIs are too configurable. Default to one path; let callers pay for the second one only when they need it.

## Example 2: Code (defensive nil + abstraction tower)

Artifact:
```ts
class UserServiceFactoryBuilder {
  build(): UserServiceFactory {
    return new UserServiceFactory();
  }
}
class UserServiceFactory {
  create(): UserService { return new UserService(); }
}
class UserService {
  getUser(id: string): User | null {
    if (id === null || id === undefined || id === "") return null;
    const user = this.repo.find(id);
    if (user !== null && user !== undefined) { return user; }
    return null;
  }
}
```

Audit:

| Anchor | Verdict | Citation | Fix |
|---|---|---|---|
| Clarity | fail | Side B: abstraction tower | Replace 3 classes with `getUser(id)` function |
| Hierarchy | fail | none | One call site; no factory needed |
| Intent | fail | Side A: defensive nil-checks | Type system rules out "" if `id: NonEmptyString` |
| Coherence | warn | none | TS strict mode rules out `undefined`; the checks contradict the type |
| Restraint | fail | Side B: parameterization, Side A: defensive checks | Inline; delete factory layer |
| Generosity | fail | Side A: silent null return | Throw with the id when not found |
| Honesty | fail | Side B: "Factory" performs architecture | Name the function for what it does |
| One-strong-moment | fail | none | Nothing in 12 lines justifies its weight |
| Invariants | fail | Side A: defensive nil-checks | Type the contract and throw on missing user |
| Audience | warn | none | Isolated snippet; name from the call site |
| Emptiness | fail | Side B: parameterization, Side A: defensive checks | Inline to one function |

Top-3 fixes: 1. Collapse 3 classes to 1 function. 2. Drop the nil-checks; lean on the type. 3. Throw with the id instead of returning null.

Revised:
```ts
function getUser(id: NonEmptyString): User {
  return repo.find(id) ?? (() => { throw new Error(`user not found: ${id}`); })();
}
```

## Example 3: Decision (ADR with weighted matrix)

Artifact:
> ## Decision: Postgres vs MySQL
> Both Postgres and MySQL have merit. Postgres scores 8.2/10 on our weighted matrix (correctness 9, ecosystem 8, ops 7, cost 8, team familiarity 9); MySQL scores 7.8/10 (correctness 7, ecosystem 9, ops 8, cost 9, team familiarity 6). The recommendation depends on which factors you weight most heavily.

Audit:

| Anchor | Verdict | Citation | Fix |
|---|---|---|---|
| Clarity | fail | Side A: 50/50 hedge | State the pick in the first line |
| Hierarchy | fail | Side B: scoring matrix | The matrix is the alibi for not picking |
| Intent | fail | Side A: "depends" | Pick one; defend it |
| Coherence | warn | none | "Decision" header but no decision in body |
| Restraint | fail | Side B: 5-criterion scoring | Two reasons suffice if they are load-bearing |
| Generosity | fail | none | No cost named for the recommendation |
| Honesty | fail | Side B: scoring performs rigor | Name the real reason (likely "team knows Postgres") |
| One-strong-moment | fail | Side A: 50/50 hedge | The decision is the moment; it is missing |
| Invariants | fail | Side A: 50/50 hedge | State the constraints the chosen option must satisfy |
| Audience | fail | Side A: "depends" | Name the audience and their actual constraints |
| Emptiness | fail | Side B: 5-criterion scoring | Two reasons suffice; leave the trade-off for the reader |

Top-3 fixes: 1. First line names the pick. 2. Drop the scoring matrix entirely. 3. Two reasons (one for, one against), not five weighted axes.

Revised:
> ## Decision: Postgres
> We pick Postgres. The team has 5 years of operational experience with it; switching to MySQL costs 6+ months of unfamiliar incident response. The trade-off: MySQL's ecosystem is broader for our planned analytics path, and we accept that cost.