How we work. Every so often we open the hood on the system behind our work. This one is about memory: the part of an AI that most businesses never set up, and the part that decides whether it gets better or just gets busier.
An AI starts every session from what it’s given to read. Give it nothing and it meets your business fresh each time: it asks the same questions, guesses at the same details, and can make a mistake you already corrected last month.
So we gave ours a library, and we use Obsidian to keep that library in order. Here is how it’s built, what it checks every time, and what it means if you want an AI that knows your business.
The short versiontap to open or close
- An AI is only as sharp as what it reads first. Each session starts from its notes, so the notes are the memory.
- We keep one vault with six shelves: the facts, the rules, the how-to, the routines, the plans and the results. Obsidian shows how they link.
- Three indexes rebuild every session, so the AI can ask “what do we know?”, “have we hit this before?” and “do we already have code for this?” before it starts.
- Checks run every session: every link, and the version of every note, so nothing quietly goes stale.
- A correction that comes up twice becomes a rule that loads every time. That’s how it stops repeating mistakes.
What Obsidian is, and what it isn’t
Obsidian is a notes app that keeps plain text files on your own computer and draws the links between them. Notes link to each other by name, and its graph view draws the whole collection as a map: every dot a note, every line a link.
Obsidian isn’t the AI. It’s the window. The AI reads the same plain files directly; Obsidian is how a person reads them, searches them and sees how they connect. That split matters: the memory lives in simple files anyone can open, not inside a tool you’d have to keep paying to reach.
One vault, six shelves
Our vault is one folder that points to six others. The files stay where they live, and the vault just gathers them in one place to look:
| Shelf | What it holds |
|---|---|
| Memory | The facts: how each piece of work runs, what we’ve learned, and the corrections we’ve been given |
| Rules | The law: what must always or never happen, written down in plain words |
| Skills | The how-to: step-by-step procedures for recurring work |
| Commands | The routines: how a work session starts, wraps up and hands off |
| Docs | The plans: designs, guides and reviews |
| Reports | The results: what the work produced |
Our code stays out of the vault on purpose. The vault holds knowledge, so a person browsing it never trips over a script, and nothing has to be filtered out by hand.
Three questions it asks before it starts
Three indexes rebuild at the start of every session, and each one answers a different question:
- What do we already know about this? An index of every note.
- Have we hit this before? One searchable line for each of our 416 working sessions, with what each one did.
- Do we already have code that does this? An index of 4,276 code files and 17,230 functions, so the AI checks before it builds the same thing twice.
The rule behind them is simple: search before you work something out from scratch. Most repeat work starts with someone not knowing it was already done.
Corrections become rules
When we correct the AI, the correction is written down as a note it reads again. We have 401 of those standing corrections, and 178 written rules.
The step that makes it stick: when the same correction comes up twice, it moves into the rules, which load at the start of every session. A correction filed somewhere it’s rarely opened only helps when someone happens to open it. A rule is in front of the AI every time.
The checks that keep it from going stale
A memory that’s wrong is worse than no memory, because the AI trusts it. So a few checks run on their own:
- Every link, every session. A checker reads all 1,475 notes in the vault each time a session starts. It flags a link that points nowhere, a note that no one can reach, and a shelf that points at the wrong folder.
- Every note carries its own history. Each memory note records its version and which work session first wrote it and last changed it, worked out from the session tags in the note itself, not from a file date that changes when a file is merely copied.
- Generated lists are never edited by hand. If an index is wrong, we fix the script that builds it, so the fix holds the next time it’s rebuilt.
On the people side, Obsidian’s dashboards show what changed in the last two days, and the graph view colors each shelf, so the bright hubs and their clusters are easy to see. If you saw the moving map on our Instagram, that’s this vault, drawing itself.
What this means for your business
The same idea works for any business that wants an AI that does more than answer questions:
- It remembers your business. The odd customer, the unwritten price, the exception everyone just knows. Written down once, read every time.
- It follows your rules. Your “always” and “never”, in front of it at the start of every session, not buried in an old chat.
- It checks before it claims. A job that finished isn’t always a job that worked, so the work is read back.
- It waits for a person before anything that reaches a customer, moves money or goes public.
That’s what our AI Engineer work builds for owners: your business context and your rules written down once, so every session starts with them, and a small first phase you can watch run before anything bigger.
Questions about any of this? Let’s talk.