is your AI's knowledge base growing, or just getting bigger?

The popular move right now is to compile your notes once into a linked wiki, then query that instead of starting cold every session.

You've done it. I've done it. We all have done it.

We've now got a second brain that gets new pages every week, and the pile feels more like a system every time, less like a folder of loose notes.

But tell me, when did you last check which pages your agents are reading?

Almost everyone who builds one of these measures the wrong thing.

They count what gets written. Pages added, links created, cross-references built.

But the wiki only grows, and almost nobody builds a check for what gets read.

So pages pile up, and some sit there unread, reached by nobody, linked to nothing.

Your agents write a page that looks right and points nowhere. A note on a tool you dropped, a rule from a project that ended six months ago.

The pile grows, the signal rots inside it, and from the outside both look like progress.

Here's where it gets expensive.

Think of your knowledge base like a fridge. You keep stacking groceries in, and the stuff you cook with, fine. But the jar shoved to the back doesn't just sit there politely. It goes off, and the day you grab it without checking the date, it spoils the whole meal.

An unread page is that jar.

The day one of your agents reaches for it, that stale page becomes the answer.

Because your agent can't tell a live page from a dead one. It pulls what it finds and trusts it, so a note six months out of date gets used anyway, and you get a confident wrong answer.

The model did its job. It trusted the base, and the base lied.

Compilers fixed this years ago. They don't just grow the program, they check what gets called and strip what doesn't. Dead-code elimination.

A knowledge base that only grows has none of that. It just gets heavier.

So here's the fix. It's boring, it works, and it's five steps:

1. Log what gets read, not what gets written.

Every time one of your agents answers a question, record which pages they opened to get there. That retrieval log, the record of what got pulled at query time, is the only honest signal of what your base is worth.

Most people have never collected it. Tbh, I hadn't either. Until recently.

2. Sort the quiet pages into three piles.

Run that log for a few weeks and some pages never come up. Don't trust that number yet, because a raw "never read" count lies, and three different things hide inside it:

Dead: never read, and out of date. The real rot.

Dormant: not read lately, but still true. Waiting for the right question.

Reference: rarely read on purpose. The glossary, the runbook, the page you only open when something breaks. Quiet by design, not decay.

Only the first pile is your problem.

It's why a script on my own base flagged 39% as dead weight, and the real number, after I sorted by hand, was closer to 16%.

The gap was dormant and reference pages the script couldn't tell apart.

3. Quarantine. Don't delete.

When you find a dead page, don't trash it. Move it somewhere the agent won't reach, a holding shelf off to the side, and wait a cycle. If nothing reaches for it there, then delete it.

You get the safety of removal without the risk of cutting something that turns out to matter.

4. Catch the page that gets read and is wrong.

This is the one almost nobody does.

Steps 1 through 3 hunt pages nobody reads, but the page that bites you is the opposite: the one that gets read a lot and is quietly stale.

So sample it. Take the pages your agents reached for most this week, and check whether they're still true.

One popular wrong page poisons more answers than a hundred orphans nobody touches.

5. Put it on a calendar.

Stale pages don't announce themselves, and they keep coming back, so this isn't a one-time cleanup.

Run the read-log, the three-pile sort, and the freshness sample once a month. Quietly, on a schedule, like backups you forget are even running.

I'll level with you. My own base isn't all the way there. I've got the diagnosis, and I've done the sort by hand.

The freshness sample is still manual, and the full loop isn't automated yet.

But I know the number now, and I know which pages to stop trusting. That alone changed what my AI harness gets right.

So before your next generation sprint, wire in the read-log first. Go in knowing how many of the pages you already have anyone is reaching.

Because a base that only grows isn't getting smarter. It's getting heavier, slower, and quietly more wrong.

Bigger and better were never the same number. Right now you probably only know the bigger one, because it's the easy one to collect.

The one that matters is reads. Go find out which side of the line your second brain is on.