Make team knowledge findable and usable

Most teams that say "knowledge management" end up with a shared folder that keeps getting deeper, or an internal wiki nobody updates. We have walked a similar road. Work at AiTOM produces decisions, specifications, research notes and handover notes every day, and it is written not only by people but also by AI assistants such as Claude and Codex. If that content lives in one person's head, one chat log or one AI's private conversation, the next person has to start by asking everyone again. So before advising anyone else, we did this on ourselves first.

Where we started

Our first problems were practical. Material was scattered, the same topic existed in several versions, and nobody could be sure which one counted. Adding AI assistants made it more visible. AI writes fluently, but early on its paragraphs often had no source: they read as correct and could not be checked. And when a chat window closed, the context disappeared and work could not resume cleanly.

We split the problem into three questions. Where should knowledge live so it survives a change of tools? How do we know whether an item is a fact, an observation or an assumption? And when an AI gives an answer, can a person see what it rests on? The answers became the backbone of our whole approach.

What we did

The core principle is one sentence: files are the source of truth. Chat history is only a helper. Project facts, decisions, results and open items are written into files that people can read directly and that can be versioned. Concretely:

• Knowledge is stored as model-independent readable files under version control, so changes leave a record and nothing depends on one AI's memory.
• Each piece of knowledge and each decision has a stable ID, and references point to the ID instead of "that document from last time".
• Content separates facts, observations and assumptions, with sources and dates, so whoever takes over can check by date instead of guessing at missing memory.
• On top of the folders sits a governance index we call the DB infra. It records what each folder is for and logs change events, so both people and AI look at the index first and the content second.
• Rules and facts are kept apart. Rules say how things should be done; facts record what actually happened. They do not share one document.
• AI answers must cite sources. A claim without one can only be marked as to-be-verified, never as a conclusion.

These look like clerical habits, but what they really buy is continuity. After any restart, an AI assistant or a colleague can read the index and the relevant files and know where things stand, why a decision was made and what comes next.

What went wrong and what we changed

The first fix was "fluent but unsourced". Early AI-written text read smoothly but was hard to verify. We added source and evidence rules: every conclusion carries a reference, and content without one is downgraded to an assumption and labelled as such. That moved AI text from "looks credible" to "can be checked".

The second fix was scope. When we let AI reorganise a large amount of content in one pass, we found unrelated pages quietly rewritten. We now limit each change to a defined scope and check the differences before release, confirming that only the expected files were touched.

The third fix was never to overwrite. Tidying is where accidents happen: you think you are cleaning up and actually cover an older version. So we keep versions, and when something must go back we revert instead of deleting. That rule has saved us more than once, because the history was still there to compare against.

What changed

Most of the change is qualitative rather than a flattering number, so we do not invent any percentages. What we can say honestly: taking over a work stream costs less, because the index, decision records and work tree are all in files; AI answers can be traced to sources, so a reviewer knows where to look; and when we switch AI assistants, knowledge does not have to be rebuilt, because it never belonged to any one model.

Equally important, knowledge became an asset that accumulates. Every decision and study has an ID and a date, so new judgements can build on earlier records instead of starting from zero each time.

What you can reuse

• Decide where facts live before you talk about tools. Files plus version control are usually the most durable starting point.
• Give important knowledge a stable ID so references do not break when something is renamed or moved.
• Require a source and date on every conclusion, and separate facts, observations and assumptions.
• Give folders a simple index and a change log so newcomers look at the index first.
• Keep rules and facts apart, and keep versions: revert instead of delete.
• Ask AI to cite sources, and mark anything without one as to-be-verified.

Knowledge does not count once it is stored. It counts when someone can find it, trust it and pick it up next time.