Everything I learned building this, including what broke.

Most people treat AI memory like a nice-to-have — something the AI figures out if you just talk to it enough. It isn't. Memory is the whole difference between an assistant and a system. An assistant is smart for one conversation and knows nothing the next day. A system remembers what you decided, why, and what's going on right now — without you repeating yourself.

So my memory setup stays simple on purpose: plain files, one job each. One for what I'm working on this week. One for every active client's status. One for decisions I've already made, so I never argue with myself about a call I already settled. The AI reads what it needs at the start of a session and updates it as things change.

Which is exactly what almost went wrong. One risky command — the kind that's fine most of the time and very much not fine the rest — reverted 403 files back to an old version, in seconds. About two months of client history and daily notes, gone. Not a bug. Not the AI's fault. A command I ran myself, without checking first what it would wipe out.

I got almost all of it back within two days — not because I'm clever, but because the AI had a record of the actual conversations where that information first came up, and I rebuilt the files from that trail. Two days, not two months. But it was way too close, and it never should have happened.

Once you start building "skills" — one file per repeated task, with its own name and its own instructions — you end up with a lot of them. I'm at 67 right now. That number should worry you a little. A library that size usually turns into a mess: you forget what half of them do, and every task turns into "wait, which one was that again?"

The fix isn't clever, it's just discipline: you don't need to remember 67 commands. You need to remember about a dozen — the ones you use daily — and let everything else route through them. I call mine the Daily 12. A short, fixed list: open the day, capture whatever just came in, reply to a client, deliver a finished project, check the money, bring on someone new. Every other skill gets reached indirectly — one of the Daily 12 acts as a front door, reads whatever you give it, and routes to the right specific skill on its own. I never have to know that skill's name. I just have to know the front door exists.

Two habits keep a library like this from rotting: keep each skill narrow — the moment one file tries to do three unrelated jobs, split it — and name things by when to use them, not what they're called, so the right skill actually fires when you need it.

Instructions tell the system what to do. They don't tell it why — and why is what keeps a decision from getting re-made, re-argued, or broken again a month later by someone (you, or the AI) who's forgotten the original reason. So I keep a running decision log: what was decided, why, and how to apply it going forward. Not a diary — a record built so nothing gets accidentally re-argued.

It has its own way of breaking, though: it only grows. Nobody's job is to clean it up, so nobody does, and it quietly turns into a file too long to actually read before making a decision — which defeats the whole point. Mine passed 400 lines with nothing ever removed since day one.

The fix wasn't deleting anything. It was splitting two jobs that had been crammed into one file: a short list of standing rules still actively true today, and a full archive of every decision ever made, kept intact, just moved out of the way. One real cleanup pass took that file from over 400 lines down to under 100, with nothing lost — just relocated. A decision log isn't "done" once you start one. It needs upkeep, or it turns into the exact mess it was built to prevent.

Everything above probably sounds like it went smoothly. It didn't. Early on, I got ambitious — I built an entire set of rulebooks for the system: one document laying out big-picture principles, another underneath it explaining how the AI should reason through problems, two more stacked on top of that. It was thorough. It was consistent. It even referenced itself correctly across all four documents, which took real effort.

Not one real skill in the system ever used it. I built four layers of structure before a single real task needed any of it. It looked like infrastructure. It was closer to decoration — impressive to look at, doing nothing the moment a real client task came through.

I caught it fast, which is the one thing I did right. Within the same week, I checked whether anything in the actual, working system pointed back to any of it. The honest answer was no. So I archived the whole thing instead of defending the time I'd already spent building it.

Here's the bigger lesson, and it's the single most important thing in this whole guide: build only what a real, repeated need has already earned. Write a rule down after you've made the same correction twice. Build a skill after you've typed the same instructions three times by hand. Add a safeguard after something has actually broken once — not before, just in case. Don't architect ahead of need. Build the smallest thing that solves today's problem, and let the system's real shape show itself through repetition.

One folder, synced somewhere you'll actually keep working from — iCloud Drive is the simplest option, a private GitHub repo (an online folder that saves every past version of your files) if you want real version history too.

One rules file — plain words: who you are, what your business does, and the two or three things the AI should never do without asking first.

Two or three skills, not twenty — your most repeated tasks, written as plain steps in their own files, the way you'd train a new hire on day one.

One memory file — what's actually going on right now. Update it as things change. Everything else in this guide is what it grows into, once repeated real use actually earns each piece.

Open it with whatever agentic AI tool you already have — Codex, Claude Code, whatever you're already using. Point it at the folder, have it read the rules file first, and try one of the skills on a real task today.