Every ops team has a documentation graveyard. SOPs written once, never updated. A wiki that was accurate for about three weeks. Decisions that live in a Slack thread nobody can find.

The problem isn't that people don't care about documentation. It's that keeping it current is a second job nobody has time for. Every meeting, every thread, every system change should update a page somewhere — and almost none of them do.

So I stopped trying to maintain the wiki myself. Now an AI does the writing and upkeep, and I do the reading, the reviewing and the deciding. Here's the pattern, and how any ops leader can set it up without writing code.

The pattern

The idea comes from Andrej Karpathy's "LLM wiki" pattern: instead of asking an AI the same questions over and over from scratch, you have it build and maintain a set of plain-text pages that get smarter with every source you add.

AI-maintained wiki workflow: raw sources feed an AI assistant that follows a rules file, writes wiki pages and checks them weekly; you read, ask questions and review.

It's just a folder with three parts:

  • Raw sources. Meeting notes, chat threads, docs, system snapshots. Saved once, never edited. This is your evidence.
  • Wiki pages. Written and updated by the AI: one page per system, process, decision, person or known issue. Every page links to related pages and lists the sources behind it.
  • A rules file. Plain-English instructions the AI reads before every task: how the folder is organized, what a page looks like, what must never be written down.

I read the result in Obsidian, which turns the links into a browsable map. But any Markdown editor works.

The rules file is the whole system

The AI is only as good as its instructions. The rules file is a single page in plain English, and it's the one thing you write yourself. Mine covers five things:

  1. Layout. Which folders exist and what goes in each: systems, processes, field mappings, decisions, people, issues.
  2. Page format. Every page starts with a title, a type, a status, a last-updated date and a list of sources. Then a two- or three-sentence summary in plain language, then the detail.
  3. Traceability. Every claim must point back to a source. Anything inferred rather than confirmed gets marked as unconfirmed.
  4. What never goes in. No passwords or API keys. No customer records. No personal remarks about anyone. The wiki holds the how and why, never the data itself.
  5. How to handle each job. Step-by-step instructions for ingesting a source, answering a question and running a health check.

I also keep a short "about me" file: my role, what I own, and how I want answers (short, plain language, always name the biggest trade-off). It means every session starts with the right context instead of a blank slate.

The three jobs

Ingest: turning a source into knowledge

When I hand the AI a meeting transcript, a chat thread or a document, it:

  1. Saves the source, unchanged, to the raw folder.
  2. Tells me in a few lines what's new or surprising in it.
  3. Updates every page the source affects, or creates new ones, and adds the source to each page's list.
  4. Updates the index and adds a one-line entry to the change log.

One meeting might touch five pages: a process gets a new step, a decision gets its reasoning, a known issue gets an owner. That cross-linking is the part no human keeps up with.

Then automate it. A scheduled task runs every weekday morning and ingests anything new from a few channels I choose: one ops chat channel, my meeting notes, our internal knowledge base, and an inbox folder where I drop notes to myself. It tracks what it has already read, so nothing gets processed twice. If there's nothing new, it logs one line and stops.

Query: asking the wiki

Any question about how something works goes to the wiki first. The AI reads the index, opens the relevant pages and answers with links to them. If the answer is worth keeping, it offers to save it as a new page, so good answers compound instead of disappearing into chat history.

Lint: the weekly health check

Once a week, the AI checks the wiki itself:

  • Broken links, orphan pages, and pages missing from the index.
  • Pages that haven't been updated in 60 days.
  • Pages that no longer match the live systems they describe.
  • Contradictions between pages.

It fixes the mechanical issues and sends me a short list of the rest.

Guardrails that make it trustworthy

An AI that writes your documentation can also confidently write wrong documentation. These four rules keep it honest:

  • Your systems stay the source of truth. The CRM, the finance system and the project tools own the records. The wiki explains the logic, mappings, decisions and owners around them. It never copies records in, so it can never become a stale second database.
  • Contradictions get logged, not overwritten. When a new source disagrees with a page, the AI records both versions and opens an entry on an "open questions" page. A human decides which is right. This one rule has surfaced more real problems than anything else in the setup.
  • Sources are kept, untouched. Because the raw material is never edited, you can always check a page against what was actually said.
  • The AI doesn't touch live systems. It reads from them to check the wiki, but changing anything in a real tool always needs a human's go-ahead.

Privacy deserves its own mention. Meeting notes and chat threads contain things that shouldn't be written down permanently: personal remarks, compensation, customer specifics. The rules file tells the AI to leave those out of the wiki pages, and the daily ingest saves chat as a curated digest rather than a full export.

The trade-offs

  • You still have to review. The AI does the writing; you own the judgment. Skim the daily summary and resolve the open questions, or errors will pile up quietly.
  • It's only as complete as its sources. Decisions made in hallway conversations never reach the wiki unless someone drops a note in the inbox.
  • It needs a home that's always on. Scheduled ingests run on a computer or service that has to be available when they fire.
  • Structure takes a first pass. The first ingest of a backlog is the heavy one. After that, daily upkeep is small.

Start this weekend

  1. Create a folder with three subfolders: raw, wiki and notes.
  2. Write a one-page rules file: layout, page format, what never goes in.
  3. Pick the single process that causes you the most questions.
  4. Feed the AI five sources about it: a few meeting notes, a key chat thread, the current SOP.
  5. Read the pages it creates. Correct them, and put the corrections into the rules file.
  6. Once you trust it, schedule a daily ingest for one channel.

Within a few weeks, answering "how does this work?" goes from "let me find out" to "here's the page." That's the difference between knowledge that lives in your head and knowledge your team can run on.

It's how I'm building the best operations in the business at Cantina.