Teach it your taste

You have felt this. The draft comes back competent and slightly wrong, and you fix the same three things you fixed last week. The fix works, the session ends, and the knowledge goes with it.

Ask it to write down what you corrected

At the end of a session where you worked something into shape together, have the agent write down the feedback you gave and what changed because of it. This is the habit that matters most in this course. Everything else builds on having it.

Before we finish: write down the feedback I gave you in this session and what you
changed because of it. Put it in guidelines.md, and keep the examples.

Do it at the end, in the same session, because that is the only moment the full picture exists. The agent has your actual words, the draft before and the draft after, and the reason you gave. Come back tomorrow and all you have is a vague sense that something was off.

You met the small version of this in memory and context, where a repeated correction gets promoted into a standing instruction. This is the same move for a whole body of work.

Then have your skills read that file. A correction sitting in a document nothing loads is a correction you will give again next week.

Not every note earns a permanent place. What repeats is a rule, and what happened once is a note. Prune it the same way you prune memory, or the file grows into something too long to load and too vague to follow.

Keep the reason next to the rule. Six months on, a rule you cannot justify is one you cannot confidently change, so the file works better as a record of what you learned than as a list of commandments.

Avoid absolutes

A few things really are never, and everything else is a matter of priority. Getting that line right is most of the work.

The genuine absolutes are worth writing as absolutes. The phrasings that make anything sound machine-written. The logo nobody may stretch, the brand colour nobody may improvise on, the customer name that never appears in an example. Those are not preferences, and a hard rule is the honest way to state them.

The trouble starts when everything else gets written the same way. Taste is mostly not a list of forbidden things. It is knowing what matters more than what else, which is not something a ban can express.

So say that instead. What is this for, and who reads it? What do you give up when the two collide? Something like: this should be understandable to someone outside the team, and if that means it is longer, longer is fine. Now the agent can handle the case you never thought to write down, because it knows which way to lean.

Give it examples rather than more rules. One thing you thought was good and one you did not, with a line on why, teaches more than five prohibitions and survives contact with situations you did not anticipate.

Zoom out

Judge the piece in front of you against everything else you have made, not on its own. Each one can be fine while the set of them is repetitive.

Nothing you have built so far can see this. Every check in the eval loops course looks at one output in isolation, and that is exactly the wrong frame for questions like these.

• Variety. Do the last five all open the same way, use the same structure, land the same shape? Left alone, repeated work drifts toward the model’s defaults, which are competent and identical.
• Consistency. Where it should look like it came from the same place, does it? Terms used the same way, the same components, the same house conventions.
• Fit. Does this one belong next to the others, or has it quietly become its own thing?

Those pull against each other, which is the point. Getting the balance right is a judgment, and it is your judgment the agent is trying to reproduce.

This needs the loading step from memory and context. An agent has to actually see the last five before it can tell you anything about the sixth, so one script that hands it everything you have done recently is what makes any of this possible.

None of this is writing-specific. The same drift shows up in code idioms, slide layouts, and the way every email you send now opens.

Build for iteration

You already know how to build applications, so build the thing that makes your feedback easy to give. That is the real lever here, and it is the one people skip.

Even with rich context a model will not be perfectly attuned to what you want. Without it, it misses entirely. So the question is not how to write the perfect instruction. It is how to get enough signal from enough rounds that what matters to you ends up embedded across every context you work in.

Make it cheap for yourself to be in that loop. In the vibe coding track you built real interfaces, and the same skill applies here. A preview that renders the thing the way it will actually be seen. A view that puts the last five next to the new one. A one-key way to say this is good, this is not, and why, at the moment you notice it rather than an hour later.

Then have skills that write what you said into memory, so the signal survives the session it came from.

Every piece of that arrives when a specific pain shows up. The loading script appears when there is too much past work to read by hand. The preview appears when you are tired of guessing. Start with the file, end your next session by asking the agent to write down what you corrected, and build the next piece when you feel the need for it.

That file is also the last piece of your toolbox. Build a plugin closes the track by wrapping the whole thing, standards included, into something you can hand to someone else.

Hands-on

Before we finish: write down the feedback I gave you in this session and what you
changed because of it. Put it in guidelines.md, and keep the examples.

Before writing anything, read guidelines.md and follow it.

Write me a script that prints everything I have finished in this folder, in full, in one go,
so you can read it all in a single call.

Reflect

• Look at the last five things you produced with an agent. Can you predict the shape of the sixth? If you can, so can everyone reading them.
• What is the correction you have given more than any other? It is still in your head. What would it take to move it into a file this week?

Recommended reading

• Claude Code memory and CLAUDE.md (Anthropic): where persistent rules live and how they load into every session.
• Agent Skills (Anthropic): pointing a skill at a reference file the agent reads before it works.