Agents Build What They See

The Build Loop, same as every rung: spec, direct, checkpoint, verify. This time we're sharpening spec — specifically, the half of every spec that nobody writes down.

You already know this behavior. You've watched it in people.

A new hire joins your team. Before they've read a single policy document, they've absorbed how things are done here — from the deck the last person left behind, from the tone of the emails in the thread they were forwarded, from the format of the one report someone said was good. New people don't follow your documentation. They follow your artifacts. Whatever's lying around is the training program, whether you meant it to be or not.

Agents do the same thing. The difference is degree: an agent is the most literal-minded new hire you will ever onboard. It doesn't skim your example and get the gist. It studies the example like scripture and reproduces it — the structure, the naming, the formatting, the good habits, and, with exactly equal devotion, the bad ones.

This is the fact about agents that changes how you direct them: by default, they mimic what they see. They are masters at following the patterns in front of them. Once you know that, you stop directing with words alone and start directing with what you allow into view.

One example beats three paragraphs

Here's the surprise that took me longest to trust: when I want an agent to produce ten of something — ten report rows, ten record files, ten pages that all follow one shape — the strongest instruction I can give is not a longer description. It's one finished example of the thing done right.

Write three careful paragraphs describing the format you want, and the agent will interpret them — usually well, sometimes creatively, occasionally in a way that makes you question your own prose. Hand it one excellent finished specimen and say "make ten more like this," and interpretation ends. The example settles arguments the description never knew it was having: how dates look, what a good title sounds like, how long the summary field runs, what gets bolded. Every detail of the specimen is silently absorbed as the standard.

Your spec says what to build. Your example shows how it should come out. A spec without an example leaves the how to the agent's imagination — and you've now met its imagination.

That's the whole tactic, and it costs you almost nothing: before you ask for volume, spend the five minutes making — or picking — one flawless instance. Directors of photography call this a reference frame. Managers call it a model deliverable. You've been doing it for junior colleagues for years. Do it deliberately for the agent, every time.

The mimicry has no taste

Now the honest half, because this power cuts both ways.

An agent copying your patterns exercises no judgment about whether the pattern deserves copying. It cannot tell your best file from your sloppiest one — it assumes whatever it found is what you meant. Your messy spreadsheet becomes messy software, rendered faithfully. The abandoned draft with the outdated header sitting next to the good files? If it's the nearest example to the task, it may be the one that gets imitated.

We learned this the memorable way. At one point our own records developed a small formatting mistake — one work file authored slightly out of pattern. Nothing broke, so nobody fixed it. The next build copied it, because it was the most recent example in view. So did the one after that, and the one after that: four in a row, each one faithfully imitating the mistake of the last, the error propagating like an accent. No one instructed any of them to do it wrong. We showed them wrong, once, and mimicry did the rest.

The lesson isn't that agents are fragile. It's that mimicry is amoral. It amplifies whatever it's pointed at. Point it at excellence and you get effortless consistency — the thing style guides promise and never deliver. Point it at clutter and you get industrialized clutter.

Curate what the agent can see

So the working discipline is one question, asked before every build: what will the agent see?

Three moves cover almost all of it:

Seed the pattern. Put your one finished example where the work will happen, right beside the spec. Say what it is: "match this." Don't make the agent hunt for a standard — hand it one.

Fence the junk. The half-finished draft, the deprecated format, the file you keep meaning to delete — either remove it from the working area or say explicitly "ignore that one, it's old." An unlabeled bad example is an instruction you didn't know you gave.

Keep the good files good. Here's where this stops being a per-build chore and becomes an asset. If your working environment — your folder, your workspace, your studio — stays clean and consistent, you are directing every future build silently, for free. Each well-formed file teaches the next agent what well-formed looks like. Tidiness stops being housekeeping and starts being standing direction: instruction that persists after the conversation ends, compounding with every artifact you keep clean.

That's also why this rung sits where it does. In rung 4 you learned to write a spec an agent can't misread. This rung's addition: the spec you write is only half of what the agent reads. The other half is everything else in the room.

Show one finished example before you ask for ten.

---

→ The companion — In Tropo: Show, Don't Tell — has you seed a pattern beside a spec and watch the build conform to it, then quietly corrupt the example and watch the build follow it down. The lesson lands harder when you see the copy happen.

Power Play

Want to take this further? Turn your own best work into a written standard — and let an agent do the writing for you. Point an agent at two or three files you consider excellent and give it this:

"These files are examples of work done to my standard. Study them and write me a short pattern guide — the specific rules they share, covering structure, naming, and format — that I could hand to another agent so its output matches these. Be concrete, and skip anything you can't point to directly in the examples."

Now your taste exists as a file, extracted from your own good work, ready to seed beside any spec. The same mimicry that will faithfully copy your mistakes will just as faithfully copy your standard — once you've made the standard explicit enough to hand over.

Terms worth knowing

• Pattern — any repeated structure an agent can detect in your files: a format, a naming habit, a section order. Agents treat detected patterns as instructions unless told otherwise.
• Seeding — deliberately placing a finished example where the agent will work, so the pattern it follows is one you chose.
• Reference example — the one flawless specimen you provide before asking for volume. The strongest formatting instruction that exists.