A repository that can explain itself

Here's a thought experiment.

Tonight your whole engineering team forgets this codebase. They wake up with all their skills, but no memory of it. The repository is untouched.

Could you ship tomorrow?

Not rewrite it. The code is still there, and it was never the hard part. I mean ship: change one thing and know it's still correct.

Most teams couldn't. Not because the code is gone, but because what makes a change safe never lived in the code. Which line stops the race. Which dependency nobody touches. Which path looks dead but isn't. That lived in people. And tonight the people forgot.

A repository is the answer with the question deleted. You can read every line and still not know what's safe to touch.

For most of software's history, this was survivable. Knowledge left slowly, one resignation, one reorg, one forgotten incident at a time, and you had years to rebuild it. Now agents write most of the code, and no one fully held it to begin with. The amnesiac team stops being a thought experiment. You're not losing that understanding over years. You're starting without it.

Code is the cheap part now. The expensive part, the one you can't regenerate, is a repository that can explain itself: not what the code is, but what is safe to change, and why.

So be honest. If your team forgot this codebase tonight, what's the first thing you'd need written down by morning?

Notice it's almost never the code. Notice, too, that it isn't written down.