DEV Community: Bethwel Kiplagat

SlothSort: The Ultimate Lazy Downloads Organizer 🦥

Bethwel Kiplagat — Sun, 25 Oct 2026 17:04:37 +0000

The Lazy Payoff

Let's be honest: nobody actually organizes their Downloads folder. Between juggling tech projects, running community events, and everyday life, dragging and dropping files into neat little subfolders is the ultimate chore. So, for the Slow and Steady challenge, I decided to channel my inner sloth and build something that does the work for me, forever.
Meet SlothSort.

It’s a local AI agent that periodically scans your chaotic, cluttered folders, reads filenames, and automatically routes them into structured directories (like /Finances, /Code, /Images, or /Trash). You literally just click a big black button, lean back, and watch your digital mess vanish. No drag-and-drop, no thinking, pure laziness rewarded.

Demo

How I Built It

I wanted the UI to be zero-friction. I built the frontend using Next.js and Tailwind CSS, heavily inspired by Mainstack's minimalist, stark black-and-white aesthetic. Soft rounded corners, bold typography, and a single call-to-action: "Do The Work For Me."

Behind the sleek UI, the backend is where the magic happens:

Local File System: A Node.js API reads the designated messy folder.
The Agent Brain: I used Mastra to orchestrate the AI logic. The agent is fed the filename and instructed to return exactly one destination category.
Local Execution: The agent calls a local instance of Gemma 2B running via Ollama to make the sorting decision, then uses Node's fs to physically move the files.

Why Open Innovation Matters Here

This project simply could not exist securely using closed-source AI.

Our download folders are filled with highly sensitive data: bank statements, tax returns, SSH keys, unreleased code, and personal photos. Sending file names like 2026_Bank_Statement_Final.pdf to a proprietary third-party API is a massive privacy risk.

By building this with open-weight models running locally, the data never leaves my machine. Open innovation means my automation works flawlessly without an internet connection, keeps my personal files entirely on my own hardware, and costs exactly $0 in API fees to run forever. It’s the ultimate set-it-and-forget-it solution.

Partner Technologies Used

Best Use of Gemma: The core decision engine of SlothSort is powered by Google's Gemma (2B). Running Gemma locally via Ollama meant I got lightning-fast inference on my laptop without sacrificing my privacy. The 2B model is remarkably good at contextualizing file names (e.g., knowing Q3_Invoice.pdf goes to Finances) with very little overhead.
Best Use of Mastra: I used Mastra as the agent framework to orchestrate the workflow between the local file system and the local Gemma model, keeping the agent logic clean and scalable.
Best Use of Sentry Agent Tracing: I integrated Sentry into the Next.js API routes to trace the agent's execution. By wrapping the Mastra/Gemma calls in custom Sentry spans (gemma-local-inference), I could monitor exactly how much latency the local LLM added to the file-sorting process and track execution times directly from the Sentry dashboard.

Conclusion

Happy International Sloth Day! Build smart, run local, and let the agents do the heavy lifting while you take a nap.

Check out the repo here: SlothSort GitHub Repository

Voco

Bethwel Kiplagat — Sun, 18 Oct 2026 18:44:18 +0000

What I Built
I built Voco, a Voice-First Event RSVP Engine designed to solve one of the biggest headaches for community organizers and field operations teams: RSVP-to-attendance drop-off.

Event organizers, tech communities (like GDG or Campus Spark), and maker labs often suffer from low turnout despite high registration numbers because standard text or email reminders get ignored. Voco solves this by allowing organizers to upload their RSVP lists and automatically generate highly personalized, human-sounding voice reminder calls or audio drops for each attendee.

Because it actually gets people in the door, local event organizers and niche community leads would gladly pay a small per-event fee ($10-$20) or a monthly SaaS subscription to use it.

Code

bethwel3001 / voco

Voice-First Event RSVP Engine designed to solve one of the biggest headaches for community organizers and field operations teams: RSVP-to-attendance drop-off.

Voco

A minimalist, Voice-First Event RSVP Engine that converts standard RSVP lists into personalized, AI-generated voice reminders to increase event attendance.

Tech Stack

React
Vite
Node.js
pnpm
Llama-3

Folder Structure

/voco: Frontend application built with React and Vite. Provides a minimalist light-mode dashboard for CSV roster uploads, campaign tracking, and audio preview playback.
/api: Backend service built with Node.js and Express. Handles CSV ingestion, MongoDB Atlas persistence, Llama-3 script generation, and ElevenLabs voice synthesis.

Use Cases

Technical community events seeking to improve registrant turnout.
Field operations teams coordinating high-touch logistics to reduce RSVP drop-off.

Hacktoberfest Integration

Render: Hosts the Node.js API and open-weight model integration.
MongoDB Atlas: Serves as the primary database for events and attendee statuses.
ElevenLabs: Synthesizes the text generated by the open-weight model into human-sounding audio.
Sentry: Traces backend API performance and monitors AI inference latency.

View on GitHub

How I Built It
Voco is designed to be incredibly lean and professional. The UI is a strict, light-mode functional dashboard built with React, Vite, TypeScript, and pnpm, heavily optimized for speed and utility.

The backend runs on Render, orchestrating the AI workflow:

Data Layer: MongoDB Atlas securely stores event details and attendee states.

Open-Source AI Core: I utilized an open-weight model (like Llama-3) to parse the attendee data (Name, Role, Event) and dynamically write a personalized, 2-sentence conversational reminder script.

Voice Synthesis: ElevenLabs takes the open-weight model's text and synthesizes a warm, energetic voice.

Observability: Sentry is integrated into the Node.js backend to trace the pipeline, monitor latency, and catch any inference timeouts when hitting the AI APIs.

Why Does Open Innovation Matter?
For a side hustle like Voco, open innovation is the only way the unit economics and privacy guarantees actually work.

Protecting Margins: By relying on open-weight models instead of closed, general-purpose APIs, the per-message generation cost remains near zero. This ensures the side hustle remains profitable even if scaled to hundreds of events.

Data Privacy: Organizers are trusting Voco with their communities' phone numbers, names, and job titles. Utilizing open-source AI ensures that attendee data isn't being fed into a proprietary black box to train someone else's model. The data stays strictly within the architecture we control.

My Agent Session
My First User
I tested Voco with a local tech community event. The organizer loved how the personalized voice clips cut through the noise of standard email reminders, and attendees felt a much stronger personal connection to the event, resulting in a higher turnout rate.

Prize Categories
I am submitting Voco for the following partner prize categories:

Best Use of Render: The Node.js backend and AI orchestration pipeline are hosted securely on Render.
Best Use of ElevenLabs: Used to generate the final, human-sounding voice narration from the AI-generated scripts.
Best Use of MongoDB Atlas: Used as the core database to store RSVP lists, event details, and campaign statuses.
Best Use of Sentry Agent Tracing: Implemented to monitor backend performance, trace the AI generation pipeline, and debug latency issues.

PORI (Phone Offline, Roam Instantly)

Bethwel Kiplagat — Wed, 07 Oct 2026 19:42:00 +0000

What I Built
Every outdoor or hiking app has the same fundamental flaw: you have to stare at a screen to use it.

For the Hacktoberfest Touch Grass challenge, I built PORI (Phone Offline, Roam Instantly). PORI is a hyper-local, audio-first urban explorer that physically forces you to put your phone in your pocket.

You input a destination, put your headphones on, and click start. The app uses real-time reverse geocoding to identify exactly which street, park, or landmark you are standing near. It then feeds that context into a localized open-weight AI model to generate a custom, highly specific walking route.

The twist? Once the route starts, PORI triggers an OLED Blackout Mode, rendering a pure black screen and locking the device awake. You cannot look at a map. You simply listen to the AI guide you past local landmarks until you reach your destination.

Demo

Live App: https://poki-six-kappa.vercel.app/
GitHub Repository: https://github.com/bethwel3001/poki

(Note: To test this properly, allow Location permissions on your device so the app can detect your surrounding landmarks!)

How I Built It & Sponsor Integrations

I built PORI using modern open-weight models, high-performance database indexing, and lightweight native browser APIs (navigator.wakeLock). Here is how it meets multiple partner prize categories:

Best Use of Gemma: Utilized Google's open-weight gemma2-9b-it model via Groq for ultra-low latency. Gemma acts as a context-aware route planner: it takes raw local reverse-geocoded landmarks and translates them into a natural, highly accurate walking script formatted specifically for a voice actor.
Best Use of MongoDB Atlas: MongoDB Atlas serves as the core data and spatial layer. The application stores location nodes and executes high-performance geospatial $geoNear queries to compute proximity and local navigation distances.
Best Use of ElevenLabs: Integrated the eleven_flash_v2_5 model to give the navigation agent a voice. Because it is an outdoor walking app, audio generation streams nearly instantly so users are never left standing blindly on street corners waiting for instructions.
Best Use of Sentry: Integrated Sentry for agent tracing and exception tracking. Monitoring execution spans allowed me to quickly diagnose and fix edge cases where empty string responses from the LLM could crash the TTS engine, letting me implement a resilient fallback layer.

Why Open Innovation Matters

When you build navigation apps relying solely on closed-ecosystem maps, you are bound by their rigid routing APIs ("Walk 50m, turn left").

By leveraging open-weight models like Gemma, I was able to instruct the AI to act as a local tour guide rather than a strict calculator. It deduces logical routes, points out interesting local quirks, and formats text specifically for audio playback. Open models allow us to build deeply immersive, customizable outdoor experiences that proprietary map APIs simply cannot offer.