How I Use Claude
← lovelace.solutionsThe files, the rituals, and how to take charge of what the AI remembers. Templates at the bottom.
READING LEVEL
01THE PROBLEM
An AI chat does remember you now. Claude keeps notes about you as you talk, carries them into the next conversation, and on paid plans can look back through your old chats. That is not the problem. The problem is who is doing the remembering.
It decides what was worth keeping, writes the note in its own words, and keeps it even after you delete the chat it came from. Nothing checks the note against what actually happened. It remembers what was said, including the things that turned out to be wrong, and it skips the things that mattered but did not sound important at the time.
It is like a new assistant who takes notes on you in a notebook you did not write and keep in their desk. You can read it and correct it in settings, and you should. But a settings page is not a document you own, back up, or hand to a different assistant.
So the fix is not to stop it taking notes. It is to keep your own, and make them the ones that count.
The old line was that an AI chat forgets you the moment you close the window. For Claude that has not been true for a while: memory is on by default, it saves topics about you as you chat, every new conversation loads them, and paid plans can search past chats on request. You can read, edit, and delete the entries in settings, and tell it mid-chat to remember or forget something.
So the problem is no longer whether it remembers. It is that the remembering is automatic. The model decides what was worth keeping, condenses it in its own words, and keeps the entry even after the chat it came from is deleted. It records what was said — the plan you abandoned, the fix a chat claimed to ship and did not — not what actually happened. Nothing checks the note against the world.
Left alone you get a memory you did not write, cannot version, cannot diff, and can only carry to another tool as an experimental export. The re-briefing tax is gone; the re-correcting tax takes its place, and it is quieter.
It's tempting to say an AI chat forgets you the moment you close the window. For Claude, that's wrong: memory is on by default, it saves topics about you as you chat, every new conversation loads them, and paid plans can search past chats. You can read, edit, and delete what it holds in settings, and tell it mid-chat to remember or forget something. It does remember. That's not the problem.
The problem is that the remembering is automatic and unverified. The model picks what counts, condenses it in its own words, and keeps the entry even after the chat it came from is deleted. It records what was said — the plan we dropped, the fix a chat claimed to ship and didn't — not what actually happened. Nothing checks the note against the world, and a wrong note is exactly as confident as a right one.
So the job isn't to give the AI a memory. It's to take control of the one it has: decide what it remembers, keep that in files you own, and make those files the thing it reads first. The re-briefing tax is gone; the re-correcting tax replaced it, and it's quieter.
State persists. Claude saves memory topics during the session, loads them on every open, and paid plans retrieve prior transcripts on request. Entries are user-visible and editable, and survive deletion of their source chat.
The defect is provenance, not retention. Memory is model-selected and model-condensed, written from utterances rather than outcomes, with no reconciliation against ground truth. Claimed-done and done are stored identically.
Unmanaged, the cost is silent correction debt: a confident, unversioned, vendor-held summary that drifts from reality and cannot be diffed. The fix is ownership — canonical state in files you control, loaded first, with the vendor memory demoted to a cache.
02THE FIX: FILES ARE THE MEMORY
So do not leave the remembering to the chat. Write the things that matter into ordinary documents — the plain kind, nothing special — and keep them somewhere you can always find. At the start of a session you show them to the AI. At the end, anything you decided goes back into them. The conversation is throwaway. The documents are not.
↻ tomorrow's session starts where today's finished
Invert it. Durable knowledge lives in a handful of plain text files kept in one canonical place and attached to the project, so every new chat reads them before it does anything else. The chat is disposable; the files are not. Anything worth keeping gets pulled out of the conversation and into a file before you close the tab.
↻ each chat inherits the last one's output
Flip the problem around. Keep your durable knowledge in a few plain text files, stored in one canonical place, and have every session read them first. The chat is disposable; the files aren't. Anything worth keeping gets pulled out of the chat and into a file — that's the whole game.
↻ next session starts smarter than the last one
Externalise state. Durable context lives in versioned plaintext masters under one canonical root; sessions hydrate at open and extract deltas back at close. Nothing durable exists only in a transcript.
↻ idempotent: replay from masters reproduces the same briefing
03THREE LAYERS OF SCOPE
Not every fact belongs in every place. Put each one at the widest level where it is still true, so you write it down once and it shows up wherever it is needed.
ACCOUNT SETTINGS
things that are always true about you — these appear in every conversation you have
PROJECT INSTRUCTIONS
how you want this one piece of work handled
PROJECT KNOWLEDGE
the actual documents and details that work runs on
Scope each fact to the widest layer where it stays true. Write it once at the right level and it reaches everything below it, instead of being pasted into three places and going stale in two.
ACCOUNT SETTINGS
your standing profile — loaded into every chat, nothing to attach
PROJECT INSTRUCTIONS
the working rules for this one project
PROJECT KNOWLEDGE
the attached files and facts this project runs on
Not everything belongs everywhere. Facts live at the widest layer they're true at:
ACCOUNT SETTINGS
who I am — loads in every single chat
PROJECT INSTRUCTIONS
how we work on this one project
PROJECT KNOWLEDGE
the facts and files of this project
Scope by widest-true. One fact, one home; lower layers inherit. Duplication across layers is drift waiting to happen.
ACCOUNT SETTINGS
global identity — always in context
PROJECT INSTRUCTIONS
per-project operating contract
PROJECT KNOWLEDGE
per-project corpus
04THE FILES
A short profile of you. Your name, what you do, the equipment you use, how you like answers written, and the mistakes you have already had to correct once. Write it once, reuse it on everything.
The house rules for one piece of work. Who makes the calls and who does the typing, and the standing instruction to look before it changes anything.
Two documents that give a project a memory. One holds the current state of play and gets read at the start of every session. The other is a dated diary you only ever add to. Between them, nothing important quietly disappears.
Your portable identity file: role, setup, preferences, and the traps you never want to explain twice. The same file drops into every project.
Rules of engagement for one project — who decides, who executes, investigate before editing, and how work gets handed off.
The project's memory. BANK is the current-state contract every session reads first; NOTES is the dated, append-only log it writes to.
Who I am: role, machines, preferences, the traps I've hit once and never want to re-explain. One portable file, dropped into every project.
How we work here: who decides and who executes, investigate-before-editing, how commands get handed back. The rules of engagement for one project.
How the project remembers itself. BANK is the contract every session reads first; NOTES is the dated, append-only diary it writes to. Together they're the project's memory.
Portable identity master. Role, hardware, constraints, known traps. Facts and pointers only, no procedures.
Per-project operating contract. Decision and execution split, step-0 investigate gate, hand-off format.
State plus journal. BANK is the read-first contract; NOTES is dated and append-only. Never rewrite NOTES.
05THE RITUALS
One word you type at the end of a real working session. It tells the AI to write the day's conclusions into the documents and to say what it thinks is worth keeping. Without it, good decisions die with the conversation.
Look before you touch. Ask the AI to read what is actually there and report back before it changes a single thing. If anything could be deleted, ask for a practice run first.
Before the AI changes one of your real documents, have it make a dated copy first. If the edit goes wrong you put the copy back exactly as it was, instead of trying to remember the old wording. Nobody tidies those copies up by hand — a weekly job clears out the ones older than a week.
Start by saying which device you are at — desk computer, laptop, phone. What the AI can reach depends on the computer the chat is connected to, not the one in your hand, and saying it up front stops it suggesting things it has no way to do. If it says it is connected, have it prove it with one quick read first.
Keep the thinking and the typing apart. One conversation plans the job and writes clear instructions; a second one, on the computer where the work lives, carries them out and never marks its own homework. If the chat is connected to that computer and can check its own results, it may do the small jobs itself and skip the hand-off.
Chat titles get made from your very first message, so they describe the question you had, not the answer you got. Rename a finished chat after what it produced and you will be able to find it again.
Put a letter at the front of the title: one for still open, another for finished. Then a glance down the list tells you what is done and what is still waiting on you.
When one conversation does work for another, ask it to finish with one short summary box: what happened, what changed, what still needs doing, and whether it already saved its notes or is leaving that to you. That box is the only part that survives being copied across. Everything else is quietly lost.
One word at the end of real work. The chat syncs its memory, appends a dated entry to the notes file, and proposes what is worth keeping.
Investigate before editing. It reads what is actually there and reports back before changing anything, and dry-runs anything destructive.
Before an edit to a master file, take a timestamped copy and confirm it is not empty. Restore from the copy verbatim if the edit goes wrong; never rebuild old wording from memory. Backups stay where they were made — a weekly sweep moves anything older than a week to a holding folder and deletes it a month later.
Open with where you are: desk, laptop, phone. Reach belongs to the machine the chat is connected to, not the device in your hand, and saying so stops it proposing what it cannot run. Connected is a tested state: one read to confirm which machine answered, before the first write.
Split planning from execution. A chat plans and writes the instructions; a second session on the machine where the work lives executes them, and never grades its own work. A chat that is connected to that machine and can verify its own result does the small hands-on jobs itself; the second session keeps the code repos and anything with bulky output.
Titles auto-generate from your first message — they name the question, not the answer. Rename finished chats by what they produced.
O_ for open, X_ for settled. Renaming at the end is your only chance to make a chat findable by its result.
End every handed-off prompt by asking for one short block: status, files changed, verify results, open items, whether it banked, next step. Only that block survives the copy-paste. Anything long goes to a scratch file at that seat, with the path reported instead.
One word, said at the end of real work. The AI syncs its memory, appends a dated entry to the notes file, and proposes what's worth keeping. It's how a session's conclusions survive the session.
Investigate before editing — always. The AI reads what's actually there and reports back before it's allowed to change anything. Dry-run before anything destructive.
Fresh timestamped backup, confirmed non-zero, before the first write to any master in a round — no exception for append-only edits. Restore verbatim from the backup, never by reconstructing prior wording from memory. Backups and scratch stay where they were made; a weekly sweep moves anything older than seven days to a holding folder and deletes it thirty days later. A rollback point that must outlive that gets a different name.
Open every session with where you are: [desk], [laptop], [phone]. Reach belongs to the host the session runs on, not the device in your hand — a phone driving a desktop session has the desktop's full reach, and a chat reaches your machines only while it is connected to one. Connected is a tested state, not a seat tag: confirm which machine answered with one read before the first write.
Two conversations, not one. A chat session plans and writes precise instructions; a second session (like Claude Code in a terminal) executes them, and never grades its own work. When the chat is connected to the machine the work lives on, it does the hands-on work it can verify itself — file edits, checks, restart-then-verify — with no hand-off; the terminal session keeps the code repos, version control, and anything with bulky output.
Chat titles auto-generate from your first message — they name the question, not the answer. Rename finished chats by what they produced, so future-you can actually find them.
O_ means open, X_ means settled. Chat titles auto-generate from your first message, so renaming at the end is the only chance to make a session findable by what it actually produced.
Every prompt handed to a terminal session is one fenced block, and ends by asking for one short block back: status, files changed, verify results, open items, bank, next step. That block is the only thing that travels back. Long transcripts and bulk excerpts do not survive copy-paste and the loss is silent, so anything long goes to a scratch file at that seat and only its path comes back.
Close-of-session trigger: sync memory, append dated NOTES entry, emit retention proposals.
Read-only investigate gate before any write. Dry-run destructive operations.
Timestamped backup before the first write to any master; restore verbatim, never reconstruct. Backups and scratch are left in place for a weekly sweep (7-day hold, 30-day delete). Longer-lived rollback points get their own name.
State the host in line one. Capability follows the host the session runs on, not the client. Connected is a tested state: one read to confirm the host before the first write.
Split planning from execution. A chat connected to the host does the hands-on work it can verify itself; a separate session owns repos, version control, and bulky output. No self-grading.
Titles derive from the opening message. Retitle on close, by artifact produced.
O_ open, X_ settled. Cheap triage across a long backlog.
Hand-offs are one fenced block in and one fenced block out: status, files changed, verify, open items, bank state, next. Bulk goes to a scratch file; only the path travels. Transcripts do not survive the copy and the loss is silent.
06THE SYSTEM CHECKS ITSELF
Once a day, something reads through all of the documents and writes a list of things that look wrong: two pages that disagree, a link that goes nowhere, a fact that has quietly stopped being true. It only makes the list. It does not change anything.
You read the list and pick what is worth acting on. The ones you accept get made as ordinary edits, the same careful way as everything else.
A second check compares what the AI said it did against what is really there. Chats will tell you something is finished. Sometimes it is not.
When a job needs a real judgement call on each item, look at them yourself instead of letting the AI guess. A guess that lands in the document you trust most is very hard to spot later. And a check you skipped is not a check that passed.
Anything that runs on a timer finishes by checking in with a simple monitor. If a job stops checking in, the monitor notices and tells you. You never have to remember to look — the jobs report in, nobody checks on them.
A scheduled job reads the whole corpus each morning and writes a proposals list: contradictions, pointers that no longer resolve, claims that stopped being true. It never edits anything itself.
Proposals land on a small review page. The accepted ones get applied by an ordinary session, through the same ritual as any other change.
A separate sweep diffs claimed-done against what is actually on disk. Chats assert things shipped; sometimes they did not.
When a batch needs judgement row by row, build a throwaway click-through page instead of guessing. Guessing quietly corrupts the file you trust most, and an unavailable check is not a passed check.
Every scheduled job's last line pings an uptime monitor. A job that stops pinging raises an alert; a job that never pinged was never finished. Jobs report in — nobody checks on them.
A scheduled pass reads the whole corpus each morning and writes a list of proposals: contradictions, pointers that no longer resolve, claims that stopped being true. It never edits anything itself.
Proposals land on a small review page. Accepted ones get applied by an ordinary session, through the same ritual as any other change.
A separate sweep diffs claimed-done against what is actually on disk. Chats assert things shipped. Sometimes they did not.
When a batch needs judgment row by row, build a throwaway click-through review page instead of guessing. Guessing quietly corrupts the file you trust most. And an unavailable check is not a passed check.
Every scheduled job's last line pings an uptime monitor. A missed ping raises an alert; a job that never pinged was never finished. Jobs report in — nobody checks on them. Idle days and broken days look identical from the outside, so the ping is the only signal that counts.
Scheduled read-only sweep over the corpus. Emits proposals — contradictions, dead pointers, stale claims. Zero write authority.
Proposals queue to a review surface. Accepted items apply through the normal session path, never the detector.
Diff asserted state against disk. Treat transcript claims as unverified until reconciled.
Row-level judgement gets a disposable review UI. An unavailable check is not a passed check.
Every scheduled job pings a monitor on exit. A missed ping raises. Push-based: nothing polls the job.
07WHEN THERE IS MORE THAN ONE PROJECT
Give each piece of work a one-page description: what it is, what it touches, and what the others must never do to it. Keep a copy of that page with the other projects, so none of them has to be explained from scratch.
One document sits above all of them and holds only the big picture — what exists and where to find it. Update it when the big picture changes, not on a timetable, and keep the fine detail out of it.
Copies drift out of date without announcing it. Before you trust one, check the date on it. Working confidently from an old copy looks exactly like working correctly, right up until it does not.
Each project keeps a short summary: what it is, what it touches, and what a sibling project must never do to it. Copies live in the siblings, so no chat starts unbriefed.
One account-level file holds orientation facts only, refreshed when an orientation fact changes, with a calendar sweep as the backstop rather than the primary.
Mirrors go stale silently. Check the version line before reasoning from a copy. Reasoning from a mirror that moved on looks exactly like reasoning correctly.
Each project keeps a short summary doc: what it is, what it touches, and what another project must never do to it. Copies live in the sibling projects so no session has to be re-briefed from scratch.
One account-level file holds orientation facts only, refreshed when an orientation fact changes, with a calendar sweep as backstop rather than the primary.
Mirrors go stale silently. Check the version line before reasoning from a copy. Reasoning confidently from a mirror that moved on looks exactly like reasoning correctly, right up until it does not.
Per-project summary: identity, blast radius, cross-project prohibitions. Replicate into siblings.
Account-level file carries orientation depth only. Event-driven refresh, calendar sweep as backstop. Cite the recipe, never the number.
Mirrors drift silently. Verify the version line before reasoning from a copy. Master wins.
08TIPS & TRICKS
- Ask for the answer in a form you can use straight away. You can always ask for the reasoning afterwards.
- Tell it to read your documents before it asks you anything. Then it only asks the one or two questions that genuinely need you.
- Do not take its word for it. If it says it saved something, have it read the file back to you, or go and look yourself.
- If it gets the same thing wrong twice, that is not bad luck — it is a rule you have not written down yet. Write it down.
- Keep the documents short. Facts and pointers, not essays. A long one waters down everything in it.
- Keep exactly one real copy of each document. Everything else is a copy, and when a fact changes you fix the real one first.
- Match the tool to the job. Quick questions do not need the slow careful setting; hard problems do.
- Finish real work by asking what is worth remembering from it — then actually save the answer somewhere.
- A "could not find it" is only as good as where it looked. Ask it to list the places it searched alongside the answer.
- Pick the model at the start of a chat and stick with it. Changing part-way makes it re-read the whole conversation from scratch, which is slow and burns through your usage.
- Ask for copy-paste-ready output. Explanations on request, not by default.
- Have it check your files before it asks you anything — then it only asks the one or two questions that matter.
- Never accept "done" from the AI's own echo. Have it read the file back, or check yourself.
- Wrong twice the same way is not bad luck, it is a missing rule. Write it into the file.
- Keep the files lean: facts and pointers, not essays. A bloated instruction file dilutes everything in it.
- One canonical copy per file. Uploads and attachments are mirrors — when facts change, fix the master first.
- Match the model to the job: quick questions on the fast one, architecture on the big one.
- End real work with "what is worth remembering from this?" — then actually save the answer.
- A "not found" is only as good as the search list — have it print the list alongside the finding.
- Model and effort are session-open settings. Switching mid-chat throws away the cache and re-reads the whole conversation at full price; switch at the next boundary, or open a successor chat.
- Ask for copy-paste-ready output. Explanations on request, not by default.
- Make it check your files before asking you anything — then it only asks the one or two questions that actually matter.
- Never accept "done" from the AI's own echo. Have it read the file back, or check yourself.
- When it's wrong twice the same way, that's not bad luck — that's a missing rule. Write it into the file.
- Keep the files lean: facts and pointers, not essays. A bloated instruction file dilutes everything in it.
- One canonical copy of every file. Uploads and copies are mirrors — when facts change, fix the master first.
- Match the model to the job: quick questions on the fast model, architecture on the big one. Don't burn deep thinking on formatting.
- End real work with "what's worth remembering from this?" — then actually save the answer.
- A "not found" is only as good as the search list. Print the list alongside the finding — absence from the wrong paths is not evidence of absence, and the report reads identically either way.
- Model and effort are session-open settings. A mid-session switch throws away the prompt cache and re-prefills the entire conversation at full price; switch at the next boundary, or treat it as a successor-chat signal.
- A verification gate is a stop condition, not a numbered step. "If you cannot verify X, stop and hand back" — a gate listed as step six of ten becomes a no-op when its tool is missing.
- Default to copy-paste-ready output. Reasoning on request.
- Files before questions. Cap intake at the one or two genuinely blocking unknowns.
- Self-report is not verification. Re-read the artifact.
- The same failure twice is a missing rule, not bad sampling. Encode it.
- Keep masters lean, facts and pointers. Bloat dilutes every line in the file.
- One canonical master per fact. Everything else is a mirror; fix the master first.
- Route by task shape. Reserve extended reasoning for reasoning, not volume.
- Close with an extraction step. Unextracted conclusions are lost at session end.
- Negative results carry their search list. Absence from the wrong paths is not evidence.
- Model and effort are session-open parameters; a mid-session change invalidates the cache and re-prefills. Switch at boundaries.
- Verification gates are stop conditions, not steps. A gate without its tool is a no-op.
09STEAL THE TEMPLATES
These are empty versions of the real documents. Fill in the blanks and drop them into whatever AI assistant you use — they are just plain text, so they work anywhere, not only with Claude.
If any of it looks unfamiliar, that is fine. Open a chat, attach the file, and ask it to walk you through what each part is for. That is a perfectly good first use of the whole system.
Last refreshed October 2026, so they match the way the real documents are used today.
Blank versions of the real files — fill in the brackets and attach them to your own projects. They are plain text, so any assistant that reads project files can use them, not just Claude.
They were written for public use rather than exported from the live files, so treat them as a starting shape, not a mirror.
Refreshed October 2026 to match current practice.
These are blank versions of the real files — fill in the brackets and drop them into your own projects. They work with any AI assistant that reads project files, not just Claude.
These templates were written for public use rather than exported from the live files, so treat them as a starting shape, not a mirror.
Refreshed October 2026 to match current practice: the hand-off rules, the backup-and-sweep ritual, and the connected-chat split are all in.
Blank masters. Fill the brackets, attach per project. Plaintext and assistant-agnostic; authored for publication, not exported from live files — a starting shape, not a mirror. Refreshed 2026-10.