Working with AI has one side effect. Documents get created far too easily.

Meeting notes, specs, analysis memos, decks, pivot decision notes. One project accumulated seventy markdown files.

The problem wasn't the volume. It was that nobody knew which of them were alive and which were dead. Write a document to organize the documents, and that document becomes the next thing needing organizing.

I assumed seeing would be knowing

The first attempt was visualization. Files as points, links and mentions between them as lines, drawn as a web.

Documents referenced by nothing and documents referenced by everything stood out immediately. The structure was visible, and I was fairly pleased.

Then I opened it to actually clean up, and something was off. However long I stared at the graph, it never answered the only question I had: can I delete this one?

After a few days I admitted it. A map and a judgment are different things.

A map tells you where things are. It doesn't tell you what to discard. To discard something you have to know what it is, and that means opening and reading it, one by one.

Visualization can't read for you. It can only order the reading.

What judgment actually needs

So I turned. Instead of drawing, I had it read.

AI agents read every document and attached to each a one-line summary, a role, and an opinion on whether to keep, archive, or merge it. The screen shows that list, and I press a decision on each.

When the decisions are done, they compile into a list, and handing that back to the AI carries through to moving the actual files.

I cleaned one project this way. The most striking moment was finding four documents sitting inside an archive folder that were still perfectly current.

The folder organization a human had done was already wrong. Organizing is a judgment made at a moment, and judgments age. A folder structure is a place where past thinking has hardened — that's what I learned there.

The price of what you look at often

Riding the momentum, I ran it across all twenty-seven projects in my personal and work folders. A page per project, and a screen collecting all of them.

Soon something odd surfaced. Keeping that screen current meant asking the AI to rescan every time. I just wanted to glance at the state of things, and every glance cost something.

So I turned a third time. The whole screen moved to a local server.

A small server built on nothing but the standard library sweeps both folders each time the page opens. Twenty-seven projects in half a second. When a new project grows its first document, it appears with no registration step.

The roles settled. Looking is done locally. Reading and producing the material for judgment is done by AI. Executing decisions is done by AI.

The biggest lesson here wasn't technical. It was placement. More than what to automate, where you put the expensive part decides how long a tool survives.

A screen you open daily that charges you each time is a screen that eventually stops being opened.

What I actually asked for

The AI wrote the code. What I did was set the constraints, and for this tool there were three.

First, no dependencies. The moment pip install is required, this tool stops opening six months from now. That is why the import list ends where it does.

from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
import html, json, os, re, sys, time, urllib.parse

Second, no cache. From the moment I can't be sure how old the screen in front of me is, I stop looking at it.

self.send_header("Cache-Control", "no-store")

Sweeping on every request meant the sweep had to be cheap. The third constraint came from there.

SKIP_DIRS = {"node_modules", ".git", ".venv", "venv", "__pycache__", "dist", "build", ".next"}

def find_md_files(root):
    for dirpath, dirnames, filenames in os.walk(root):
        dirnames[:] = [d for d in dirnames if d not in SKIP_DIRS]

Slicing dirnames[:] in place is the whole trick. Build a new list and rebind the name instead, and os.walk never learns about the pruning and descends into node_modules anyway.

I was curious, so I dropped the pruning and swept the same two folders. Two tenths of a second became 9.5 seconds, and the md count went from 477 to 16,481. Those extra sixteen thousand are mostly READMEs inside other people's packages.

Reading the code I got back, that is the place I checked. Not what had been built, but which line my constraint survived in.

What three turns taught me

That screen now sits permanently on one side of my monitor. I've picked up the habit of glancing at a project's document map before going in, and a rising count of unreferenced documents reads as a signal that cleanup is due.

Looking back, this tool was built by passing through three rounds of this isn't it.

That I needed a list to decide from, not a visualization. That material for judgment only comes from reading. And that what you look at often should be kept close.

Admitting quickly that something is wrong has always been faster than getting the design right the first time. The luxury of building tools alone is being able to do that as often as you like.

It was a tool built to organize documents. What actually got organized was my thinking about them.