On June 29, 2026, I found out that my AI assistant had not been reading some of my most important rules, and that it was not its fault.
By then we had written hundreds of small memory files: lessons, traps, preferences, rules I had stated right after something went wrong. A single index file listed them all, and the assistant read that index at the start of every session. The index had grown to about 308 kilobytes and around 600 entries. What neither of us had noticed was that the assistant loads only the first part of that file automatically, roughly the first 200 lines. Everything below that line was silently cut off. Rules I believed were saved never reached it.
We rebuilt the index that day, from about 630 lines down to 114. The detailed files stayed on disk. The index kept only the rules that must be read every time, plus pointers to everything else.
The short answer
An AI coding assistant forgets everything between sessions, so you make it remember with files: a short project instructions file it reads every session, a folder of small memory files that record each lesson with its reason, saved procedures called skills for recurring jobs, and parallel helpers called subagents for wide work. Then you maintain that system like anything else in your business, because a memory that is too long or overwritten silently stops working.
Think of a brilliant employee who forgets each evening
A modern coding assistant works inside your project folder. It can read every file, run commands, edit code, save versions and talk to your online services. That power is exactly why it needs structure. To make a forgetful employee productive, you would give them five things:
- An onboarding handbook read every morning: the project instructions file.
- A notebook of lessons where every mistake and preference is written down: the memory.
- Checklists for recurring jobs: skills.
- Helpers sent off on separate tasks at once: subagents.
- Keys to the rooms they need, and only those: connections to your database and GitHub.
The assistant forgets. Your files do not.
The instructions file
Most coding assistants look for a special instructions file in the project folder and read it at the start of every session. For Claude Code that file is called CLAUDE.md. It is plain text. You write it once and improve it over time.
KashBoss never had a classic instructions file in its main folder. A design file and the memory index did that job, but I would start any new project with a short one on day one. It should say what the product is and who uses it, where the main folders are, which rules must never be broken, how you want to be spoken to, and what the assistant may do alone versus what needs your approval.
Memory: many small rule files
Our memory folder holds hundreds of small text files, each recording one thing. They fall into three kinds: working rules about how I want work done, technical facts and traps, and project records of a feature or incident. Each file has the same shape: the rule, why it exists (usually the real incident behind it), and how to apply it. The "why" matters most. A bare rule gets applied too strictly or not at all. A rule with its story lets the assistant judge new situations.
Memory also needs a habit. We set up an automatic reminder, called a hook, that fires when the assistant finishes a piece of work and asks it to save anything worth remembering. If nothing noteworthy happened, it saves nothing.
When I want something remembered on purpose, I say so directly:
Memory that was full, and memory that was overwritten. The first problem is the one from the opening: an index that grew past what the assistant loads, so rules below the cut-off were silently ignored. The second came later. I often ran two assistant sessions at once. Both read the memory index when they started and both rewrote it when they saved. In late August 2026, a line one session had added disappeared an hour later, because the other session saved its own older copy over it. The detailed files were safe; only the shared index collided.
The rules we follow now: the index stays short, one line per rule, with details in separate files. A size limit is written at the very top, in plain sight whenever someone edits. Finished work moves to an archive index. And after saving, the assistant checks that its new lines are still in the index before it tells me "saved."
Skills: saved procedures for recurring work
A skill is a ready-made procedure the assistant can run on request, like a checklist with expertise built in. Two skills became part of every piece of code we write. The first is a high-effort code review, a careful read of the changes looking for bugs. The second is simplify, a cleanup pass that removes duplication without hunting for bugs.
On September 28, 2026, I made them mandatory, in a fixed order: finish the code, review it, fix what the review confirms, simplify, run the relevant tests, and only then say "done." The same day showed why. We had just built a feature that stores product photos on Cloudflare. A live test passed 16 out of 16 checks. The review then found two real security holes the live test had missed: a photo link could point to another account's storage with a small trick at the end, and pasting the link with different capital letters slipped past a check. A live test proves the normal path works. A review looks for the paths you did not think to test.
Subagents: several helpers at once
A subagent is a second assistant, started by the first, that works on a separate task and reports back. They help in two situations. One is wide investigations: on May 30, 2026, I asked for a complete check of the program with eight read-only auditors in parallel, one per area such as stock, sales, cash boxes and accounting entries. The other is large mechanical changes, such as adding a "share on WhatsApp" button across the program, which touched 44 files. The pattern that worked was that the main assistant builds the shared piece first, then gives each helper a separate group of files with the rule to add only, never to change existing logic.
Never trust a helper's "done." After parallel work, the main assistant must check every target file itself, then run the checks on the whole project.
In July 2026 one of four helpers stalled with a file half-edited. Its report said "failed," but the half-finished work stayed on disk, and trusting the reports alone would have shipped a broken file. Helpers also use your subscription faster, so use them only when the task is truly wide.
Key takeaways
- An AI assistant forgets between sessions. Instructions files and memory files are how it remembers.
- Memory needs maintenance: keep the index short, keep details in separate files, and check that saves really landed.
- Make review, fix and simplify a fixed routine after every piece of code, because live tests and reviews catch different problems.
- Use parallel helpers for wide or mechanical work, and verify every file they touch yourself.
- Give the assistant read access freely and write access carefully, with rehearsals before any change to live data.
Frequently asked questions
What is a CLAUDE.md file and do I need one?
It is a plain text instructions file in your project folder that Claude Code reads at the start of every session. It tells the assistant what the product is, where things live, and which rules must never be broken. You do not strictly need one, but I would write a short one on day one of any new project.
Why does my AI assistant forget my rules?
Assistants start each session empty, and long sessions push early details out of working memory. Rules must live in files. Also check how much of your memory index is loaded automatically: ours was silently cut off after roughly the first 200 lines, so rules below that line never reached the assistant.
Are parallel AI subagents worth it for a beginner?
Only for wide jobs, like checking many areas of a program or making the same mechanical change in dozens of files. They use your subscription faster, and they can leave half-finished work behind. If you use them, make the main assistant verify every file afterward.