Example: From Repeating Yourself to Never Again

In short

The exact same job done three times, in three different conditions.
Only where the information lives changes: in your head, in a file, or in its own notes.
The payoff isn't in the first round: it's from the second one on.
And it shows what doesn't belong in permanent instructions.

The job

Every Monday morning you take the documents that came in during the week, rename them with the date and client name, sort them into the right folder, and put together a list of what arrived.

A boring, repetitive, always-the-same job: the perfect candidate.

Monday 1 — you explain everything

You open Claude Code in the folder and tell it the whole story: how clients are named, what format you want for the names, which folders things go into, that documents starting with "draft" get ignored, and that you want the list at the end in a text file.

It works. It took you ten minutes to explain and two to get it done. And in seven days none of it will be left: the desk emptied out the moment you closed it.

Monday 2 — the written instructions

This time, before starting, you run /init. It looks at the folder and proposes an instructions file with what it worked out on its own: which folders exist, how files are usually named.

Then you add the three things that can't be seen from the folder, written the way they should be — short and checkable:

file names go in the format year-month-day client;
files starting with "draft" don't get touched;
at the end of every reorganization, update the list in the file arrivals.txt.

Now Monday's request is down to a single line: "do this week's reorganization." You no longer repeat the fundamentals: it reads them on its own when it starts.

Monday 3 — memory does the rest

A case comes up that wasn't in the instructions: a client who sends documents under two different names. You tell it once — "these two names are the same client, always use the second one" — and it notes it down on its own.

The following Monday you don't tell it again. And when you see the line about recalled notes pop up, you know exactly what's happening, because you saw it in the last lesson. You go check what it wrote for itself, it checks out, you close it.

From here on the job takes two minutes, and neither of the two original ten-minute steps repeats anymore.

The thing we did NOT put in the instructions

Notice something: in all of this we never wrote the procedure into the instructions file. We wrote facts — formats, folders, exceptions — and made the request out loud.

If we'd also written the twelve reorganization steps in there, those twelve steps would have sat on the desk in every session, including the ninety-nine where you're doing something completely different.

Long procedures need a different home: one that only loads when it's needed. That's the next chapter.

And now

Second bucket closed: you know what Claude knows about you and how to make it find things already written. In the next chapter we turn the things you redo the same way every time into procedures you can call up with a word.

Did you get it?

Two minutes, no grade. Trying to answer — even getting it wrong — cements the concepts far more than rereading. Not in the mood? Skip it: the lesson still counts as complete.

In the example, what changes between the first and second session?

Which of these things does NOT belong in CLAUDE.md?

1
1. 1
2. 2
3. 3
2
1. 4
2. 5
3. 6
4. 7
3
1. 8
2. 9
3. 10
4. 11
5. 12
4
1. 13
2. 14
3. 15
4. 16
5. 17
6. 18
5
1. 19
2. 20
3. 21
4. 22
5. 23
6. 24
6
1. 25
2. 26
3. 27
4. 28
5. 29
6. 30
7
1. 31
2. 32
3. 33
4. 34
8
1. 35
2. 36
3. 37
4. 38
9
1. 39
2. 40
3. 41
10
1. 42
2. 43
3. 44
11
1. 45
2. 46