# Writing down taste

Early on in building [Home Port](https://andrewdurden.com/), a fresh agent session asked me a layout question I had already answered two hours earlier.

On a normal afternoon at a laptop, you just type the answer again and move on. When you're steering an entire 3D room, copy pipeline, and site launch from your phone between real life, repeating yourself kills your trust fast. You immediately start wondering what *else* quietly vanished the last time a container restarted or a context window compacted.

I told the lead session plainly that repeating myself cost my trust, and set one rule over everything else: **never ask me something I've already answered.**

People talk constantly about waiting for smarter models, yet on long projects raw model IQ is almost never what trips you up. Memory is. Personal taste evaporates at every session boundary unless you build plain, durable places in the repo for it to live. None of ours are fancy, and almost all five exist because something broke first:

```
CLAUDE.md                  short house rules, including "Working with Andrew"
docs/owner-words.md        everything I said or tapped, dated, newest first
docs/design/rulings.md     tie-breaker rulings that hold until I overrule them
docs/copy/.../SKILL.md     on-demand playbooks so root context stays lean
tools/copy/check_deck.py   script that breaks the build on altered copy or dashes
```

## Keep `CLAUDE.md` short enough to actually get read

Everyone's first move with a `CLAUDE.md` or `AGENTS.md` file is treating it like a company Confluence wiki and dumping two thousand lines of wishful thinking into the root folder. Because that file loads into every single session, bloated rule files turn into background static until the model quietly ignores half of what you care about.

In my own `SKILL.md` files, the cap is hard: keep root `CLAUDE.md` files under 200 lines. Put in exact build and test commands, architectural boundaries the agent can't infer from reading the code, and recurring gotchas. Leave everything else out.

Early on, we added a compact `"Working with Andrew"` block to ours: batch multi-part questions onto my tappable phone page, never ask twice, lean into rich Miami color and material texture, default to less, stop spinning on unrequested polish, show rendered pictures instead of long text pitches, and remember I'm reading on a phone.

Here are three of those bullets verbatim from the repo:

```markdown
- **Never ask him twice.** Before asking anything, check docs/life-inventory.md,
  the exhibit notes in docs/exhibits/ and the answers on the questions page.
- **Default to less.** (2026-11-13, three times in one day: "maybe some are
  too busy"; "it's a bit busy with these...")
- **Show him pictures, not paragraphs.** Render or mock it, then ask.
```

Stamping the date and my exact quote next to a rule turned out to matter a lot. And whenever the lead session inferred a rule on its own rather than quoting me, it tagged the line `"The lead's reading, not his words"` so future sessions knew what was stone tablet versus what was open to pushback.

## Never let an agent paraphrase your taste

AI summaries sand off all the edges that make taste useful. Early on I told the lead: `"I don't like that brass plate aesthetic for cards. I am much more of a color and texture person"`. An automatic summary compressed that into `"User prefers warm styling"`. Read that summary cold in the next session and you have zero clue why brass looked tacky or why tactile cloth book covers worked.

So we kept one dated file (`owner-words.md`) holding everything I typed, dictated, or tapped on the phone pages, word for word, typos and all, sorted newest-first by topic. Right at the top sat one line: `"Check here before asking him anything."`

```markdown
- **2026-11-13**: "I don't like that brass plate aesthetic for cards. I am much
  more of a color and texture person. I like something that has texture,
  character, illustration, text". Standing rule for the interface, the
  coffee-table books and the wall art.
```

By repo law, that file outranked every architecture doc and agent opinion. Every new builder read it before touching UI, and every critic persona read my past thumbs-up and thumbs-down notes on renders before grading new ones so their bar stayed calibrated to mine instead of generic internet defaults.

## Written rulings and lazy-loaded skills

Real feedback is messy, especially mine. More than once I dropped in a long copy or positioning doc I'd brainstormed in another chat, and while nine ideas sharpened the site right away, one stray line accidentally contradicted a boundary I'd locked two days earlier.

Instead of guessing silently or pinging my phone with ten nitpicky questions, the lead made a clear call, logged it with the date inside `rulings.md`, and kept moving unless I overruled it later. Two of my favorite standing laws landed in there after early misses. At one point, the lead pitched a portfolio concept in text built around a marching-band halftime show. My entire reply was six words: `"I hate the marching band idea"`. Paired with an early draft that described my work way too sleepily, those misses became two permanent rules: **show frames, not paragraphs** and **run his work before describing it**.

Skills handle the opposite problem: keeping specialized instructions out of the way until they're needed. Not every coding session needs to know how to bake Cycles lightmaps, audit privacy metadata, or structure a 5-Whys product discovery pass. Moving specialized workflows into standalone `SKILL.md` files means sessions pay zero token tax until the task actually calls for one. Putting my own four product and eval skills up on [Home Port](https://andrewdurden.com/) is just sharing those exact internal playbooks so peers or students can drop them into their own repos.

## Anything that truly matters becomes a build failure

Prompts and markdown files are polite advice. If a rule actually matters, put it in a script that breaks the build.

You can write `"NEVER USE EM DASHES"` in bold all-caps ten times inside `CLAUDE.md`, and at 2:00 AM on a deep context window an LLM will still sneak one into a subhead out of pure training-data muscle memory. So every non-negotiable rule moved into Python and Playwright gates:

- **Verbatim copy lock:** A script pulls my approved copy into one JSON deck, and `check_deck.py` fails immediately if any rendered string drifts by a character, blows past its length budget, or sneaks in a banned dash or typed arrow.
- **Scars turned into checks:** Whenever a real mistake reached my phone screen, it graduated into an automated test that same day. At one point I opened a test screenshot where the illustrated book jackets looked totally wrong and texted in mild panic: `"you didn't change the font and look of the books recently did you???"` Nothing had changed; headless test runs block external web fonts by design, and someone had sent me a raw test capture. After that, review screenshots ran through a font-readiness check, and the book covers converted to locked vector outlines at build time. Another check banned signing off on visual fixes from tight zoomed-in crops alone.

The punctuation check itself is four lines of Python, and it has caught more late-night LLM habits than every system prompt combined:

```python
for bad, name in (("—", "em dash"), ("–", "en dash"), ("->", "typed arrow")):
    if bad in t:
        err("%s: an %s in printed text" % (path, name))
```

## The cold-repo "stranger test"

A few days in, with our weekly quota on the heavier frontier model running tight, I asked a practical question: `"is the task list so explicitly defined for us until completion that a model with less attention could follow it still?"`

Instead of guessing yes, the lead wrote a launch runbook and ran a blind test. It spun up a brand-new session on a lighter model, handed it *nothing* except the repo on disk, and quizzed it against twelve real judgment calls the lead had faced. The cold agent answered all twelve the way the lead would have, and the gaps that read turned up got patched in the markdown files. Once it passed, I flipped the live session onto the lighter model and kept shipping without losing a step.

People treat taste like mysterious creative smoke locked inside a founder's or designer's head. Working with agents strips the romance right off of it: taste is context. Write it down in your own words, date it, and back the non-negotiables with a script that refuses to blink, or every new session meets you like a stranger.
