Too Many Files to Keep Up With? I Built a Local Service: Drop Them in a Folder, AI Renames, Sorts, and Indexes Them

In the AI era, everyone’s capacity to process information has been multiplied many times over. I used to read and write maybe a few files a day, and I could manage them by hand quite neatly—building a personal knowledge system in Obsidian, Notion, or Evernote. Being the fussy, J-type person I am, I’d even work out a consistent naming scheme for every file before saving it, so I could find it later.

Then the AI era changed that. My daily output climbed to dozens of files, sometimes over a hundred, and keeping that manual system alive was beyond me. So I worked out an approach and put it into practice. I’m sharing it in the hope that it sparks something for you.

A local service that watches a folder

This little program monitors one folder on my machine. Every time I drop a file in, it uses a model to read the file’s contents, then automatically renames it, classifies it, and builds a thorough index—all according to my own habits.

The design goes like this. I have a temp folder holding everything I download plus every file people send me over chat apps. These files have bizarre names and come in every format imaginable. The background program continuously watches that folder for changes and determines the file type:

• documents or images go to Claude, reading and viewing on subscription quota;
• audio or video go to Gemini for analysis.

All I do is tell it my standard, drop the file in, and wait a moment. It sorts and processes everything the way I specified, and builds a thorough index I can page through in a browser. It splits things into folders by content type—the ones I use constantly are meeting notes, video scripts, health records, financial information, plus client proposals and knowledge and methodologies I’ve collected.

The key part: two retrieval middle layers

This approach fits me especially well, because a lot of what I produce with AI is web documents, or audio and video whose contents can’t be searched directly. The industry-standard Obsidian approach turns everything into Markdown files for storage and management. But staring at a pile of plain text littered with markup is hard work for a human—nowhere near as direct as just looking at the web page or the proposal itself.

But flip it around: web pages and multimedia are unfriendly document formats for an agent.

So I built two of what I call “retrieval middle layers.” There’s exactly one goal: when I need something, or an agent needs to call something, it knows which document to reach for and which pieces of information to pull into context for further processing. So after the model finishes reading a file, it doesn’t stop at giving it a memorable name—it boils the contents down to a short summary and tags it the way I’d tag it, which builds a directory listing meant for agents to read.

If what lands in the temp folder is a folder rather than a single file, it recognizes that too—and if it identifies the folder as a piece of software stored in folder form, it packs it into an archive and stores that. The whole process takes somewhere between a dozen and twenty seconds.

Demo: loose files in the root, everything in its place a dozen seconds later

Let me demo. This folder has already been through a first pass. Let’s simulate a mess: throw it some files with no names and no classification and watch what it does. Drop in what needs processing, wait a dozen seconds, and it finishes sorting on its own. Refresh the folder and the loose files in the root are gone—they’ve been moved into specific folders.

Open the video folder and you can see it renamed things in a standard format after interpreting the content: a specific date, the content type, then a one-line content summary. Same for audio. That image I just dropped in got automatically identified as “full-body character art of a male in 3D anime style” and stored in the right place.

This is only the first layer of organization. It also hooks into a lot of Claude Code scheduled jobs—for example, the financial folder has invoices in it, so it periodically fills out my expense reports from those invoices (I have a separate episode specifically on that skill and the invoice-filling capability). It also links this content back to my corresponding projects. How? Because it built a very detailed set of indexing rules and an index layer over those folders. Here are the ninety-odd files I haven’t archived recently. Every one has a filename plus a one-line index entry, so an agent can find it and call it fast.

The same goes for the web pages, other documents, and images Claude Code produces: they all get generated into this temp directory and renamed, classified, and stored in real time. And CC remembers the process, which eliminates the old embarrassment of wanting a file and not being able to find it.

It isn’t a skill, it’s a local service

To be clear: this isn’t a skill. It’s a local service I built. Take my source code and modify or extend it—everyone organizes files differently. But this approach genuinely satisfies my organizing compulsion, and it’s saved me an enormous amount of time.

Going further: distill your identity core

There are extensions worth trying. When I consult for clients, a lot of those web pages contain large amounts of my methodology, my views, my value ordering. One extra thing I do is periodically extract that material into an “identity core” document. With that document in place, Claude Code makes decisions and executes according to my value ordering when planning, drafting proposals, and doing the work—which makes my CC better and better.

That’s it for today. See you tomorrow.

Today’s service is fully open source and free (MIT); the repo is at github.com/xntj-ai/guiwei. It’s a local background service, not a skill—take the code, plug in your own model keys (documents and images via an OpenAI-compatible endpoint, audio and video via Gemini), tweak it to your own filing habits, and it’s ready.

Source: EP0055_audio.mp3 · ASR model gemini-2.5-pro (chunked parallel) · full text of the original recording

[00:00] Today’s episode solves a big problem. In the AI era, every person’s capacity to process information has gone up many times over. Before, we might only read or produce a handful of files a day, and we could manage them by hand just fine—with tools like Obsidian, Notion, or Evernote, building your own knowledge system. And a fussy J-type like me would give those files very systematic filenames when storing them, so it’d be easy to go back and look things up later. But in the AI era, that situation changed.

[00:25] The number of files I produce in a day has turned into dozens, sometimes over a hundred. I have absolutely no capacity to keep doing that under the old system. So I came up with a good approach and actually built it, and I hope it gives you some ideas too. This little program can monitor a local folder, so that every time you drop a file in, it can use a large model to read the file’s contents, automatically rename and categorize that file, and build a thorough index. And all of that follows my own working habits.

[00:50] So let me walk you through the whole design. I have a temp folder, and that folder holds everything I’ve downloaded, plus everything people have sent me in chat apps. Those files have weird, random names and come in all kinds of types. First, a background program keeps watching that folder for changes and figures out what type each file is. If it’s a document or an image, it hands it to Claude to read and look at using my subscription plan quota. If it picks up that the content is audio or video, that goes over to Gemini’s

[01:15] model for the analysis. All we have to do is tell it a standard and throw the files in. Give it a second and it gets categorized and processed the way I specified, really fast. And it also builds a very thorough index. And to make it easy for me to just open a browser and look things up, it splits things into different folders by content type. There are the meeting notes I use all the time, my voiceover scripts, my health records, even financial information. There are also the proposals I’ve sent clients, plus knowledge and methodology I’ve come across. So what’s good about doing it this way? For me,

[01:40] as the user, it’s extremely friendly. Because a lot of the files I produce with AI are web documents, or audio and video where there’s no way to search the content directly. Whereas the way the industry usually does it, with something like Obsidian, everything gets turned into Markdown MD files for storage and management. And for a human, reading plain text with all kinds of markup symbols in it is genuinely painful. Nowhere near as direct as just looking at the web page, or looking at the proposal. But web pages, proposals, and multimedia are, for an

[02:06] agent, an unfriendly document format. So what I do is build two retrieval middle layers, for lack of a better name. And the purpose is just one thing: when I need to use something, or when an agent needs to call something, it can know which document to go find and which pieces of information to pull into context for further processing. And after the model has analyzed the file, besides giving it a memorable name, it also pulls out a summary layer of what’s in it, and tags it according to my working habits, forming a directory listing for the agent to look at. If what you drop into that temp folder

[02:31] is a folder rather than a file, that gets recognized too. If it recognizes a piece of software stored as a folder, it’ll zip that folder up into a compressed file for storage. The whole process finishes in somewhere between fifteen and twenty seconds. I’m going to share the source code for this too—DM me for it. Let’s demo the whole operation. The folder you’re looking at now is one that’s already been roughly organized. Let’s simulate a mess and throw it a bunch of files that haven’t been renamed and haven’t been categorized,

[02:56] and watch how it handles them. So we drop the ones that need processing in here, and then we wait—give it ten, fifteen seconds, and it’ll finish sorting it out on its own. All we have to do is refresh the folder and we can see it’s put the files into the corresponding folders. Very smooth. Once it’s done you can refresh this folder, and you’ll find that the loose files in the root directory are gone. They’ve been placed into specific folders. For example, if I open this video folder, you can see that after reading the content it renamed things using a standard format—a specific date, the content type,

[03:22] then a short summary of that content. And besides video, audio works the same—the same renaming process. That image, the one we just dropped in, was automatically recognized as a full-body character illustration of a male character in 3D anime style, and stored here. Now, that’s only the most basic first layer of organizing. It also connects to a lot of the scheduled tasks in my Claude Code. For instance, in the finance folder there’s an invoice type, and it’ll periodically fill out my expense reports with the invoices for me. I have another episode about that skill and the invoice-filling capability.

[03:47] And it also links these contents into the corresponding projects of mine. How does that work? Because it set up a very detailed set of indexing rules and an index layer for that folder. This is roughly 90-some files I haven’t archived recently, sitting in here. Every one of them, on top of the filename, gets a short index entry, so an agent can search and call it fast. And likewise, the web pages my Claude Code produces, and any other document types, and images, all get generated in this temp file directory too,

[04:12] getting renamed, categorized, and stored in real time. And CC remembers this process, which avoids that awkward situation we used to run into where you want to find a file and you can’t. Now, this feature isn’t a skill. It’s a local service I developed. You can take my source code and do your own further development and adjustment on it, because everybody’s thinking on organizing files is different. But this approach really has massively satisfied my organizing compulsion and saved me time. And there are some other things you can do with it. For instance, in my client consulting there are a lot of

[04:37] web pages that contain a whole lot of my methodology, my views, and my value ordering. So one extra thing I do is periodically extract that content to form a document of my identity core. And with a document like that, when Claude Code is doing planning, doing proposals, doing execution, it makes decisions and executes according to my value ordering. It makes my CC better and better to use. So that’s what I’ve got for you today. See you tomorrow, bye-bye.