Your wiki is becoming a codebase

Almost nothing I write today starts from a blank page anymore. Plans, team updates, posts like this one: I write them all with the help of agents. A year ago, I didn't work this way.

Until recently, there was one big exception: our company's knowledge base. The pages everyone relies on, like our strategy, specs, and processes, were still written and updated by hand, so they fell behind like they do everywhere.

I think the way companies maintain knowledge will change, and it will look a lot like how we maintain code. Agents will write and update most of it, people (and soon other agents) will review it, and every change will meet the same accuracy standards and testing rigor.

How every wiki eventually dies

Every company has a place where it keeps what it knows, whether it's called a wiki or a knowledge base. Someone writes a page, and someone else reads it later, sometimes much later.

In between, nobody keeps it up to date. The people who know the most are the busiest, and checking old pages is no one's job. So the product, the team, and the plan all change, and the page stays the same.

You've probably followed a page like that, only to have a coworker tell you it changed months ago. That's how every wiki dies: one out-of-date page at a time, until nobody trusts it and everyone just asks in Slack.

Agents only know what's written down

Agents keep getting smarter, and they can see more of the company than ever. But they don't hear about changes in the hallway. They only know what got written down.

A person who finds an old page can check it against everything else they know. An agent can only check it against other pages and messages, so when an old page and a newer Slack thread disagree, it has to guess. A smarter agent guesses better, but it sounds just as convincing when it's wrong.

And agents are doing more and more of the reading. On the public docs we host at Mintlify, more than three-quarters of the traffic now comes from agents, and internal knowledge is heading the same way.

An out-of-date page used to mislead a few people. Now it can mislead every agent that reads it.

The work is moving faster

Agents are also speeding up the work itself. My cofounder Hahnbee recently talked with a product manager at a large enterprise software company. Agents have multiplied what his team of 15 can ship, and when she asked if it was hard for the rest of his org to keep up, he said, "1000% yes."

He also told her he won't trust an agent's recommendations until it knows his product strategy and OKRs. But those pages don't change nearly as fast as the work does.

Agents made the work faster. Nobody made the knowledge work faster to keep up.

Better search won't fix it

Most knowledge tools are responding by adding AI on top: a sidebar that answers questions, a summarize button, a connector so agents can search. These help agents find pages, but they don't make the pages correct.

Someone still has to write every page, put it in the right place, and remember to update it. That's the part that never worked, and it's why the knowledge falls behind the work.

Finding the page was never the hard part. Keeping it true is.

Do what engineers did with code

Engineers solved this problem for code a long time ago. A computer does exactly what the code says, so mistakes are expensive. That's why every change to code is tracked, reviewed, version controlled, and easy to undo.

Knowledge never needed that, because people could fill in the gaps. Agents can't, so knowledge needs the same care.

The simplest way we've found is to keep knowledge as files in Git, the same tool engineers use for code. Every page has a full history, every change can be reviewed, and the files stay yours. Claude Code already edits files like these all day, and other agents can reach them through an MCP server.

It also means people and agents work from the same place, so an agent that answers a support question can update the page it used.

Structure pays off too. In our controlled test with a large engineering team using Claude Code, agents working from structured docs gave 64% more precise answers and used about half the tokens compared with raw code.

Nobody should write alone

Most engineers don't write code alone anymore. They work with an agent in their editor that drafts with them, asks what they meant, and catches mistakes as they go.

Writing knowledge should feel the same. The agent shouldn't be a summarize button off to the side. It should sit beside you as a copilot and thought partner, pulling in context from other pages, pushing back when something doesn't add up, and flagging when what you wrote contradicts what's already there.

Let agents do the upkeep

An agent shouldn't only help while you write. It should also keep the page current after you're done. For as long as companies have had wikis, that's been the hard part, and now agents can do it.

Andrej Karpathy described how he does this for his own research: an AI turns his source material into wiki pages and checks them for gaps and contradictions, and he rarely edits them himself.

Over the next couple of years, I expect agents to take over most of this upkeep at companies too. A person reviews each change, the way an engineer reviews code.

Picture a pricing change that ships on a Friday. By Monday, an agent has drafted fixes for every page with the old price and flagged a sales playbook that no longer matches. Someone approves them before lunch.

We've already seen this work for docs, where Autopilot keeps documentation up to date as code ships.

People will still decide what's true. They just won't have to type it all up.

Where we're starting

We've been dealing with this problem internally, so we built a solution for ourselves. For the past three months, we've been dogfooding it across the company, with nearly a thousand pages in one place where our people and our agents work from the same files. It's changed the way we work.

Today, we want to share it with you. It's called Mintlify Base, and it's in beta because we want to build the next version with the teams using it. You can check it out at mintlify.com/base.

The companies that move fastest will be the ones that get the most out of agents. That means putting them to work, and giving them the right information to do it well.