DEV Community: Viktor

Sloth AI Folder Tidier: Let Open-Source AI Clean Your Downloads Folder So You Don't Have To

Viktor — Sat, 24 Oct 2026 10:02:48 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady

What I Built
Let’s be honest about the Downloads folder. For most developers and students, it is a digital graveyard. Mine had accumulated exactly 962 files—a chaotic mix of university PDFs, C# snippets, .jar game mods, audio tracks, and 40 different setup_v2_final(1).exe installers.

Why don't I clean it? Because of the Hoarder’s Paradox:

I am way too lazy to sort nearly a thousand files manually.
I am too paranoid to bulk-delete anything because "what if I need that random file from 4 months ago?!"

To channel my inner sloth for International Sloth Day, I built Sloth AI Folder Tidier—an automated file organizer designed specifically for lazy digital hoarders.

Instead of blindly sorting by file extension, it scans file age, size, and peeks at the first 150 characters of text/code files. Using open-weight models, it understands context and neatly organizes chaos into logical folders (University_&Docs, Code&Dev, Gaming&Mods, Media&_Music, etc.) with three golden safety rules:

Zero-Deletion Policy: The script literally does not contain a delete function. Nothing is ever lost.

The Sloth Vault (Sloth_Vault_Old): If an installer or archive hasn't been touched in over 30 days, the AI quarantines it. Out of sight, out of mind, but still there if you panic.

1-Click Undo (--undo) & Dry-Run (--dry-run): Every move is logged locally. One command reverts your entire folder back to its original messy state in 1 second.

Demo

Code

Shadow16Ua / Sloth-Folder-Tidier

How I Built It
The project is a Python CLI built around fast, open-weight models (qwen/qwen3.8-27b and openai/gpt-oss-20b) running via the Groq API.

Metadata & Micro-Context Extraction: Rather than uploading whole files, the script uses pathlib and os.stat to extract lightweight metadata (filename, extension, age in days, size) and reads a tiny 150-character preview for plain-text/code files.

Structured JSON Batching: To process hundreds of files efficiently without hitting rate limits, the script chunks the files into batches of 15. These are passed to the model with response_format={"type": "json_object"}, forcing the open-weight model to act as a deterministic routing engine rather than a chatty assistant.

State Reversibility: Every shutil.move operation is recorded in a sloth_history.json state file, allowing deterministic rollback.

Why Does Open Innovation Matter?
When building a tool that inspects your personal filesystem, open-source AI isn't just a nice-to-have — it’s mandatory:

Privacy of Personal Files: Nobody wants to send a list of their private university documents, local source code, and personal filenames to a closed, proprietary corporate cloud that trains on user prompts. Because this architecture uses standard open-weight models, you can run it via fast zero-retention APIs (like Groq) or eventually swap the base URL to run it 100% offline via Ollama.

Set It and Forget It (Zero Cost): A folder tidier is a background utility you run weekly. Using highly capable, smaller open models means inference is practically free, allowing a true "set it once and be lazy forever" workflow.

Model Swappability: Closed APIs lock you in. While building this, several models were decommissioned on my inference provider. Because I was using open models, I simply swapped my array from gemma2-9b-it to qwen3.8-27b and gpt-oss-20b in exactly five seconds without rewriting a single line of parsing logic.

The Lazy Payoff
I am my own first user. My Downloads folder had 962 files spanning over a year of university assignments and freelance coding projects. Sorting that manually would have taken at least an hour of tedious dragging and dropping.

With this script, I typed one command, leaned back, and watched the AI process 65 batches in a few seconds. My folder is completely clean, my old installers are quarantined in the vault, and I didn't have to lift a finger or make a single decision. Pure sloth perfection!

AI QA-Assistant for Freelance Audio Transcribers (Hacktoberfest Week 2)

Viktor — Sun, 18 Oct 2026 11:23:18 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle

I built Transcriber-QA-Toolkit, an automated QA pipeline designed for freelance audio transcribers and data annotators.

Transcribing the audio is only 20% of the job. The other 80% is formatting the text according to strict guidelines: checking specific tags like , converting numbers (Inverse Text Normalization), fixing mathematical symbols, and recovering accidentally missed words from the audio.

This single-script toolkit solves that problem by automating the Quality Assurance and gap-filling process. It analyzes the timestamps of JSON transcriptions, slices the original audio to recover missing words using Whisper, and strictly formats the entire text batch using an open-weight model.

Who would pay for it: Freelance transcribers are paid per audio minute. By cutting QA time by 90%, this tool effectively doubles their hourly rate. Transcription agencies would also pay a subscription for a local, automated QA tool that ensures their workers' output is 100% compliant with client guidelines before submission.

Demo

Code

Shadow16Ua / Transcriber-QA-Toolkit

How I Built It
The project is built around a single, powerful Python script (groq_batch_fixer.py) running on Groq's high-speed inference API for extreme speed, paired with FFmpeg for audio processing.

Whisper Audio Gap Recovery Human transcribers often miss words. The script analyzes the start and end timestamps in the JSON file. If it finds a silence gap greater than 0.5 seconds, it extracts that specific audio chunk via FFmpeg and runs it through whisper-large-v3 to catch any missed speech.

gap_duration = start - last_end if gap_duration > 0.5: gap_text = transcribe_with_whisper(AUDIO_PATH, last_end, start) if gap_text and re.search(r'[а-яА-Яa-zA-Z]', gap_text): print(f"➕ [Found missing speech]: {gap_text}")

Strict Batch Normalization Using a strict system prompt and zero-shot/few-shot examples, the script batches the transcription segments and sends them to LLaMA (e.g., llama3-70b-8192 or llama3-8b-8192). The model acts purely as a formatting algorithm, applying Inverse Text Normalization (ITN), fixing punctuation, and managing strict spacing rules around tags, while preserving the original spoken words.

Why Does Open Innovation Matter?
For the transcription side hustle, open-source AI is a strict requirement, not just a preference:

Strict NDA & Privacy: Freelancers work with highly confidential audio (medical, legal, unreleased products). You cannot send this data to closed APIs that might train on user data. Open-weight models like LLaMA and Whisper guarantee that client data never leaks, especially if the user eventually decides to run the inference entirely locally via Ollama.

Cost Efficiency: Running open models on fast inference providers like Groq costs a fraction of a cent per task, making the freelance business model actually viable.

Niche Fine-Tuning: Generic closed models are terrible at following highly specific formatting tags (like keeping without surrounding spaces). Open-weight models follow strict rules predictably for structural tasks without trying to be "chatty assistants".

My First User
I am my own first user! I work as a freelance audio transcriber and data annotation contractor. Before building this, I spent hours manually checking JSON files against strict guidelines. Now, I just run the script, review the automated fixes, and submit my tasks. It saves me hours of manual QA every single day, directly increasing my actual hourly earnings.

TouchGrass AI: Local Gemma 2B Micro-Adventure Generator

Viktor — Sat, 10 Oct 2026 08:02:15 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass

What I Built

TouchGrass AI is a lightweight, offline-first web application that generates hyper-local, 3-step micro-adventures. The goal is simple: make the screen the shortest part of the experience.

You select your current environment (e.g., a local park, city center, or quiet neighborhood) and the time you have available. The app instantly generates a unique real-world observation quest. Instead of scrolling, you get specific physical tasks-like finding a distinct architectural feature, observing specific colors in nature, or completing a walking challenge. You lock your device, put it in your pocket, and actually interact with the physical world around you.

Demo

Code

Shadow16Ua / TouchGrass-AI

How I Built It

AI Engine: Google's open-weight gemma2:2b running locally via Ollama.
Backend: .NET 10 Minimal API (C#) to handle the prompt pipeline and schema enforcement.
Frontend: Vanilla HTML, CSS, and JavaScript with a responsive, nature-accented dark UI.

The core challenge was taming a lightweight 2B model to generate realistic, physical tasks instead of fictional role-playing narratives (initially, it tried to send me on a detective quest to investigate a fictional neighbor). By enforcing a rigid JSON schema in the C# backend and explicitly restricting the prompt from inventing fictional characters, the API reliably outputs highly contextual, real-world tasks formatted as clean JSON arrays.

Why Does Open Innovation Matter?

Building this with an open-source model was mandatory for the core concept to work:

100% Offline Capability: You can generate a trail quest in the middle of a deep forest where there is zero cellular signal. Because it runs locally on a laptop, it doesn't need an internet connection to function.
Total Privacy: Your location context, available free time, and walking habits are never sent to a corporate cloud server or API provider.
Transparency & Control: Working directly with local inference allowed me to rapidly iterate on prompt constraints and see exactly how gemma2:2b processes spatial context, allowing me to adjust my C# backend to perfectly parse and sanitize its raw output.

Prize Categories

Best Use of Gemma

StudyBuddy AI: Taming Gemma 2B to Build a Local Quiz Generator for a Friend

Viktor — Sun, 04 Oct 2026 14:39:41 +0000

Who I Built It For

My friend is currently preparing for university exams and technical interviews (focusing on databases and C#). Reading dry documentation gets boring quickly, so I wanted to build an interactive, multiple-choice quiz partner that tests their knowledge on any given topic. Since it's for a student, it had to be completely free and accessible without internet restrictions.

What I Built

I built StudyBuddy AI — a lightweight, completely local web application that generates 3-question multiple-choice quizzes on any subject.

GitHub Repository: https://github.com/Shadow16Ua/StudyBuddy-AI

The Tech Stack:

AI Model: Google's gemma2:2b running locally via Ollama.
Backend: .NET 10 Minimal API (C#) to handle prompting and JSON parsing.
Frontend: Pure HTML, CSS, and Vanilla JavaScript (with a sleek dark mode).

📸 Demo

Why Open Innovation Matters Here

Choosing an open-weight model like Gemma 2B over a closed API (like OpenAI) was crucial for this project for three main reasons:

Zero Cost & Privacy: My friend can generate hundreds of quizzes without worrying about API limits, subscription fees, or sending their study data to a third-party server.
100% Offline Capability: It runs perfectly on a standard laptop CPU, meaning they can study during commutes or internet outages.
The Engineering Challenge (Taming the 2B Model): This was the most interesting part. I quickly realized that small 2B models struggle to output complex JSON arrays (like 3 questions at once). It would constantly hallucinate structures or merge answers. Because I had full control over the local inference, I was able to completely redesign the backend pipeline. Instead of asking for 3 questions in one prompt, my C# backend asynchronously asks Gemma for one question, exactly 3 times in a loop, and then manually constructs a bulletproof JSON array. This guarantees perfect UI rendering every single time. I also shifted the "shuffle options" logic to the frontend to prevent the AI from confusing correct/incorrect indexes.

Open source allowed me to iterate rapidly, observe the raw output locally, and engineer a robust wrapper around a lightweight model to make it perform like a much heavier one.

Note: I'm submitting this project for the Best Use of Gemma category as well!