Meli AI Mentoring

5.4

They keep one home for their standards so a single edit upgrades every project at once

Chapter Editorial Status: Early Draft

Chapter Editorial Status

Agent instructionsPaid book

Copying a rule into every project means improving it once requires fixing it everywhere

Picture a shared kitchen with one master recipe binder on a stand. Your family and the babysitter all cook from that one binder. The day you improve the lasagna page, you fix it once, and the next person to make lasagna gets the better version without anyone telling them. Now picture the opposite: every cook keeps their own photocopy taped inside a cabinet. To improve the lasagna you would hunt down all thirty copies, and the ones you miss keep cooking the old way. Over months the copies drift, someone scribbles a note on one, and nobody can say which copy is right anymore. The same choice shows up in how you keep the rules for how you want your AI work done.

By now you have prompts, specs, and workflows you have refined, and you keep the canonical versions in formats you own. The next question is where the rules inside them live: the way you want documents summarized, the tone your writing should hold, what counts as finished. The easy habit is to paste those rules into every project that needs them, a copy here, a copy there. The moment a rule lives in thirty places, you have signed up to maintain thirty copies, and they start drifting the day you make them. You tighten the summarizing rule in one project and forget the other twenty-nine still hold the loose version, so your work stops sounding like one person made it.

The fix is the binder on the stand. You keep each rule in one official home, and every project holds a short note that points to that home rather than its own copy of the rule. Improve the rule once in its home, and every project that points to it serves the better version the next time it runs. Nothing drifts, because there are no copies to drift. One rule carries the rest of the idea: how you want long documents summarized, the kind of rule you have probably already pasted into several projects without thinking about it.

Two of these ideas already have names that power users borrow from software, where keeping one home for shared knowledge is old, settled practice. The prose so far has built the feel by hand. Here are the names for what you are protecting, so you can ask for it precisely.

The pointer is the part that makes a single source of truth work in practice, and it has its own name. A project should hold a short note that says which rule to follow and where it lives, not a duplicate of the rule itself. That note is a pointer.

Pointing means one edit upgrades every project at once

The payoff of pointing is the thing the photocopy-in-every-cabinet habit can never give you. When every project points to one home, improving how your AI works is a single edit, not a search across thirty copies. You decide that summaries should now name what is still uncertain at the end. You change that one rule in its home. Every project that points to it, the research project, the client-update project, the one you set up last week, serves the new version the next time it runs, because each of them was reading the live rule the whole time. You did not visit a single project to push the change out, and none of them quietly kept the old way.

There is a second payoff that the binder analogy makes obvious. Because there is one home, you can see how your thinking changed and undo a change you regret. With thirty scattered copies, the history of an idea is smeared across thirty files and lost. With one home, the story of how your summarizing rule got sharper lives in one place. You can ask your agent to show you, in plain language, what changed in your standards over the last month, and to roll back a change that turned out worse. Your judgment becomes something you can read, track, and revise, instead of a habit you half-remember.

Keeping standards separate from the model means a model swap never touches your judgment

There is a deeper reason to keep your standards in one home you own, and it comes from a difference that is easy to miss. The AI model is rented and keeps changing; your standards are yours and stay put. Models update every few months, and each version shifts in what it is good at and how it behaves. Your rule for how a summary should read does not need to shift just because a new model shipped. Keep the two separate and you get a clean split: a model swap never has to touch your judgment, and sharpening a rule never has to wait for a model release.

A short pointer read first keeps the request lean and the model sharp

Keeping one home does more than save you edits; it keeps the AI itself sharper. When a project points to the home, the agent reads a short note first and opens the full rule only when the task needs it. Compare that with pasting the same long rule into thirty projects, where every request carries the whole thing whether the task needs it or not. The pasted version bloats the request, and a long instruction has a known weakness: a model uses what sits at the start and end of its input best and can miss a fact buried in the middle of a long passage. A short pointer keeps the important rule where the model will use it best.

One home also tends to be cheaper and faster on work you repeat. A rule that lives at a fixed place and rarely changes is exactly the kind of input these systems can reuse across requests rather than re-reading from scratch every time. You do not have to manage any of that. You keep one canonical home, and the savings come from the home being stable and shared instead of pasted fresh into every project.

Copies creep back in, so a regular check is how you keep one home honest

One home stays valuable only as long as it stays the one home, and the pressure runs the other way. In a hurry, it feels quicker to paste a rule straight into a project than to point at the home and trust the pointer. The moment a project pastes a rule inline instead of pointing to the home, drift has started again, quietly, one copy at a time. That single inline copy will not get the next improvement, and a month later you are back to wondering why one project sounds a little off.

You catch this the same way you would catch a photocopy taped back inside a cabinet: you look for it on a schedule, and you do not do the looking by hand. Have your agent sweep your projects for any rule that got pasted in instead of pointing to your home, and convert it back to a pointer. Run it every so often, the way you would tidy the kitchen. The sweep keeps the home canonical, so the promise of the whole system, one edit upgrades everything, stays true instead of slowly eroding.

Build one home for your standards and point every project at it

Build one home for your standards and point every project at itPaid book · Claude builds one canonical home for your rules, converts copied-in rules across your projects into short pointers, sets sessions to read the home first, and sweeps for copies that creep back. You decide which rules belong in the home.

Sweep your projects for copies that should be pointers

Sweep your projects for copies that should be pointersPaid book · Claude scans your projects for rules that were pasted in instead of pointing to your home, lists each one, and converts the ones you approve back into short pointers. You approve before anything changes.