# My friend's laptop is full of junk nobody dares delete. So I built him a local AI that explains what's safe. > Source: > Published: 2026-10-05 00:58:07+00:00 *This is a submission for the [Hacktoberfest Weekend Challenge: Build for a Friend](https://dev.to/challenges/hacktoberfest-weekend-2026-10-01)* Every one of my friends has the same laptop problem, and so do I. We download everything: installers, zips, ISOs, datasets, entire SDKs for one assignment. And we delete almost nothing. When the "C: drive is almost full" warning finally shows up, we open Downloads, delete a few obvious things and give up, because the rest of the space is hiding in places none of us know about. My friend **Kunal** is the worst case. His laptop is always filled with random downloads, caches, trash and other things nobody remembers putting there. Cleaning it means guessing which folders are safe to delete, and since nobody wants to guess wrong, most of it just stays. So I built **DiskSage** for him: a Windows app that scans the whole PC for junk, then has **Gemma 4, running locally on the laptop**, explain every finding in plain English: what it is, whether it's safe to remove, and why. It looks in the places we never check: `node_modules`, `.venv` and Rust `target` folders in projects you haven't opened in months. There's also a **Remove an app** tab. It runs the app's official uninstaller, then finds the settings and data folders the app leaves behind. And there's an **Ask** tab for questions like "is it safe to delete WinSxS?", answered using what the scan found on *your* PC. The first time I ran it on my own laptop, it found **25.4 GB that was safe to clean**. The biggest single item was a 15.5 GB unpacked SOLIDWORKS installer still sitting in Downloads, long after the app was installed. The demo runs in this order: scan → Gemma reviews every finding → it identifies the mystery folders → confirm cleanup → remove an app → ask a question. File names are blurred with DiskSage's own "Blur file names" button. There's no live link, and that's on purpose: a hosted DiskSage would have to scan *someone else's* PC. Here are two screens up close. **Gemma identifying folders no rule could name.** Here it spots the Android SDK and the Dart/Flutter package cache, both still in use, so it says keep: **Removing an app completely.** DiskSage runs the official uninstaller, and Gemma explains each leftover folder. It warns that `Arduino15` may hold your own sketches: **Finds the junk on your Windows PC, and explains it with an AI that never leaves your machine.** My friends and I download everything (installers, zips, ISOs, datasets, whole SDKs) and delete almost nothing. Downloads is the junk you can see. The rest hides in temp folders, browser and app caches, `node_modules`, pip/Gradle/Cargo caches, driver installer leftovers and forgotten AI models. DiskSage scans for all of it. A local, open-weight model (running in [Ollama](https://ollama.com)) then reviews every finding and explains, in plain English, what it is and whether it's safe to remove. Nothing is deleted until you tick it and confirm. On my own laptop, the first scan took 5.5 seconds and found **25.4 GB that was safe to clean**. The biggest single item was a 15.5 GB unpacked SOLIDWORKS installer sitting in Downloads. | Where | Examples | |---|---| | **Downloads** | Setup files for apps you've **already** | To try it on Windows: ``` ollama pull gemma4:e4b git clone https://github.com/ttspb1357/disksage ``` Then double-click `DiskSage.bat`. It checks for Python and Ollama, installs what's needed and opens the page. **Stack:** `gemma4:e4b`) ``` Scanner (Python, read-only) Gemma 4 on this laptop You ─────────────────────────── ────────────────────── ─── walks folders, measures, ──► verdict + reason for ──► tick what hashes duplicates, reads every finding (JSON), to remove installed apps, matches identifies mystery │ installers to apps folders, advises on apps ▼ actions.py re-checks every path → Recycle Bin, or delete if it rebuilds itself ``` | Finding | Size | Verdict | |---|---|---| | Unpacked SOLIDWORKS installer (app already installed) | 15.5 GB | safe | | pip, Gradle and Cargo caches | 3.7 GB | safe | | Rust `target` folder in a project untouched for 336 days | 1.6 GB | safe | | Setup files for 6 apps already installed (Anaconda, OBS, Arduino…) | 1.4 GB | safe | | Chrome and Edge caches | 1.4 GB | safe | | App caches (VS Code, Riot Client…) | 1.3 GB | safe | | Conda package cache | 14.8 GB | review: "use `conda clean --all` " | | ASUS driver folder `C:\eSupport` | 6.1 GB | review: "MyASUS may still use it" | | An Ollama model I no longer use | 4.9 GB | review | | Android SDK + Dart/Flutter cache (mystery folders) | 3.0 GB | Gemma: keep, still in use | | `hiberfil.sys` +`pagefile.sys` | ~20 GB | keep, with how to shrink them properly | Python does everything that has a right answer: `VSCodeUserSetup-x64-1.93.1.exe` to "Microsoft Visual Studio Code". Gemma does everything that needs judgement: *what is this, is it safe, and what's the catch?* Every scan ends with one structured call to the local model. DiskSage sends the findings (titles, sizes, paths, the scanner's own notes) along with a JSON schema through Ollama's `format` parameter, so the answer always comes back as verdicts and reasons the app can use directly. This is a real one from my scan: ``` { "id": "F9", "verdict": "review", "reason": "This is a large cache for Conda packages; you should use the `conda clean --all` command in the Anaconda Prompt for the safest removal." } ``` Mystery folders get a second, more focused call. The scanner can't name `AppData\Local\Pub`, but it can tell Gemma the folder's age and the names of a few things inside it. That was enough for Gemma to recognise the Dart/Flutter package cache. That's the rule I didn't compromise on, together with a second one: **the model can only make a verdict *more* cautious, never less.** A small local model guesses wrong sometimes. The first model I tried confidently called my ASUS driver folder "installer leftovers for an Autodesk product". So: `python-3.10.0-amd64.exe` belonged to `.cab` files. Deleting one would break the installer, so unpacked installers are now detected and offered as one whole folder.`pagefile.sys` to 17.7 GB while the model was loaded. DiskSage now explains that file instead of ignoring it. I tested the delete code on a throwaway folder (18 checks), on Python 3.10 and 3.13. One check plants a junction trap pointing at "important" files; those files survived. Another simulates a switched-off Recycle Bin. I also clicked through the whole UI with a browser-automation script, with every destructive request intercepted (22 checks). **Because the input to this app is a list of your file names.** To tell you what's junk, the model has to read names like `Resume_final_v3.pdf`, client project folders, bank statements and folders named after people. It also reads your AppData, which is basically a list of every app you've ever installed. A cloud API would receive all of that on every scan. With Gemma running in Ollama, the request goes to `127.0.0.1` and stops there. I wouldn't send a listing of Kunal's laptop to anyone, and with DiskSage I don't have to. Open also made it practical: `DISKSAGE_MODEL`); nothing else in the code changed. Where closed would win: a frontier model knows more trivia, and would probably have named that ASUS folder correctly the first time. I chose privacy and zero cost, and designed around the smaller model's limits: measure the facts, let the model judge, never let it act alone. For a tool that reads your file list, that's the right trade. **Best Use of Gemma.** Gemma 4 (`gemma4:e4b`) is DiskSage's engine, running locally through Ollama on a laptop GPU. It powers all four AI features: Every call uses structured output, so Gemma's answers go straight into the interface as verdicts, reasons and notes. Across every test run (full scans, app advice and questions), it returned valid structured answers each time. A full review of about 18 findings takes 25–35 seconds and uses 4.7 GB of GPU memory, and no data ever leaves the PC.