DEV Community: David Nizeyimana

Sloth: a lazy local AI tool that tidies files and summarizes chats, built with Gemma, Ollama and GitHub Copilot

David Nizeyimana — Sat, 24 Oct 2026 22:19:55 +0000

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

What I Built

I built Sloth, a small command-line tool that does two things for me so I don't have to.

The first one is sloth tidy <folder>. It takes a messy folder, like Downloads, and sorts the files into:

Documents
Images
Videos
Audio
Archives
Code
Other

It shows me what it plans to do first. It only actually moves the files when I use --apply, and it never overwrites an existing file.

The second one is sloth digest <file>. It takes an exported chat or notes file and gives me a short two-line summary: what the conversation is about and whether there is a decision, task, or deadline.

Both commands use Gemma 3 (1B) through Ollama, running directly on my laptop. So there is no cloud service, no API key and no extra cost. It is basically a little AI tool running on my own computer to help me be lazy.

Demo

Here is some real output from my machine:

$ node src/index.js tidy /tmp/messy
app.js -> Code/app.js
budget.xyz -> Code/budget.xyz
holiday-selfie -> Documents/holiday-selfie
lecture-recording -> Videos/lecture-recording
notes.txt -> Documents/notes.txt
photo.jpg -> Images/photo.jpg
report.pdf -> Documents/report.pdf
song.mp3 -> Audio/song.mp3

$ node src/index.js digest chat.txt
Amina and Joe will meet at 3pm, with the report deadline being Friday noon.
No action needed

And honestly, not all of this output is correct. I'll explain that below.

Code

davidnize / sloth-cli

A lazy local AI command-line tool: sort files and summarize chats with Gemma and Ollama. No cloud, no API keys.

sloth-cli

A lazy local AI command-line tool powered by Gemma and Ollama. It does small chores for you, entirely on your own machine: no cloud, no API keys, no cost.

Setup

Install Ollama and keep it running.
Pull the model: ollama pull gemma3:1b
Install Node.js 18 or newer, clone this repo, and run commands from its folder.

Usage

node src/index.js <command>

Commands:

tidy <folder> [--apply]
digest <file>

`tidy`

Sorts the files in a folder into category subfolders (Documents, Images, Videos, Audio, Archives, Code, Other). The local model picks each category, with a fallback to the file extension if its answer is invalid.

node src/index.js tidy <folder> is a dry run and only prints the planned moves.
node src/index.js tidy <folder> --apply creates the folders and moves the files.
Existing files are never overwritten. The model runs with temperature 0 and a fixed seed, so a dry run and…

View on GitHub

How I Built It

The AI

I used Gemma 3 (1B) through Ollama. The tool talks to Ollama's /api/generate endpoint running on localhost. The project itself is just plain Node.js with no dependencies.

For tidy, the AI looks at each file and chooses one category from a fixed list. If the AI gives me something that isn't one of those categories, or if Ollama isn't available, the program falls back to using the file extension.

For digest, I send the last 6000 characters of the file to Gemma because, for chats especially, the most recent messages are usually the most useful. Then I take the first two non-empty lines from the response.

How GitHub Copilot fits in

I wrote very little of the actual code myself. Instead, I created GitHub issues and assigned them to GitHub Copilot's coding agent.

This is what I did:

Issue #1 — CLI skeleton and the Ollama helper → PR #2
Issue #3 — tidy command → PR #4
Issue #6 — bug I found while testing → PR #7
Issue #8 — digest command → PR #9

I still tested every pull request myself before merging it. I wasn't just letting Copilot write everything and hoping it worked.

The Bug

While testing tidy, I found something I didn't like. I ran it as a preview first, and notes.txt was supposed to go into Documents. Then I ran it again with --apply, and the AI decided to put the same file in Other. The model was giving a different answer each time, which meant the preview wasn't actually a promise of what was going to happen.

So I opened Issue #6 and had Copilot fix it by making the model deterministic, using a temperature of 0 and a fixed seed. After that, the preview and the actual run gave me the same plan.


![ ](https://dev-to-uploads.s3.us-east-2.amazonaws.com/uploads/articles/2qvsrw9avbs11n67ppdw.png)

Something Copilot Got Wrong

There was another thing I caught while reviewing the fix. Copilot originally put temperature and seed at the top level of the Ollama request, but Ollama expects those settings inside an options object. So they were basically being ignored.

The funny part is that Copilot's own test still passed because the test was checking the wrong place too. I caught this while reviewing the pull request, commented on it, and Copilot fixed it in another commit.

That was one of the more interesting parts of building this because it reminded me that even when an AI writes the code, I still need to understand what the code is actually doing.

When the Credits Ran Out

While working on the digest pull request, Copilot ran out of its monthly credits. It couldn't fix an old test that was still expecting digest to say "not implemented yet", and a Copilot review request also failed because of the quota. So I fixed that test myself.

I also added a GitHub Actions workflow myself so that every push and pull request runs the full test suite.

I had also planned to build a third command called cards, but I decided not to force it into the project just because I had planned it. I'd rather leave it out than ship something half-finished.

Why Does Open Innovation Matter?

For me, the biggest reason is that the AI actually stays on my computer. tidy needs to see my file names and digest needs to read my chats or notes. I don't really want to send those things to some random online API just to organize them. With Ollama and Gemma, they stay local.

It also means:

No API key
No API bill
No internet connection needed once the model is downloaded
I can control the model settings myself
I can change the model without changing the whole project

The model name is basically in one place, so trying a bigger Gemma should be as simple as changing that.

Of course, there is a downside. The 1B model isn't that good. You can see that from my own output. It put holiday-selfie into Documents and budget.xyz into Code. The digest command also said "No action needed" even though the chat clearly had tasks in it.

So I'm not going to pretend this is some perfect AI assistant. A larger Gemma might do much better, but I haven't tested that yet.

My Agent Session

I didn't use DevRelay for this. The whole process is visible in the GitHub repository through the issues and pull requests. You can see Copilot's plans, commits, session information and my review comments.

Issue #1 / PR #2: https://github.com/davidnize/sloth-cli/pull/2
tidy: https://github.com/davidnize/sloth-cli/pull/4
Bug fix: https://github.com/davidnize/sloth-cli/pull/7
digest: https://github.com/davidnize/sloth-cli/pull/9

The Lazy Payoff

I haven't tested Sloth enough to say something like "it saved me 10 hours." I only tested it with sample files and a short sample chat, so I don't want to make up a number.

What I do like is the preview-first approach. I can look at what Sloth plans to do, make sure it looks right, and then use --apply. So instead of manually sorting everything myself, I just check the plan once and let Sloth do the boring part.

I wanted to be a little lazier.

Prize Categories

Best Use of GitHub Copilot

Most of the project was built by creating issues and assigning them to Copilot's coding agent. I also included the parts where Copilot wasn't perfect: the bug it fixed, the mistake I caught in its fix, and the point where it ran out of credits and I had to take over. I think that shows the actual process better than pretending the AI wrote perfect code from the beginning.

I also added GitHub Actions myself so the tests run automatically on every push and pull request.

Best Use of Gemma

Gemma 3 (1B) is the only AI model in the project. It runs locally through Ollama and is used for both tidy and digest. Nothing is sent to a cloud AI API.

Pocket Ledger, a local expense log for freelancers

David Nizeyimana — Fri, 16 Oct 2026 02:29:40 +0000

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

What I Built

I built Pocket Ledger, a local expense log for freelancers.

The idea is simple. Freelancers have a lot of small expenses: a train ticket, lunch with a client, office supplies, a software subscription, or a utility payment.

You enter a description, an optional merchant, an amount, and a date. Pocket Ledger saves the expense, lists your entries, shows the total, and lets you remove an entry when you need to.

The part I wanted to add was automatic categorization without sending those expense details to a hosted AI service.

When Ollama is running, Pocket Ledger uses qwen2.5:3b locally to choose one of these categories:

Advertising
Meals
Office supplies
Software
Travel
Utilities
Other

It also generates a short note explaining the categorization.

A freelancer could pay for a tool like this because their expense descriptions and merchant names stay on their own computer instead of being sent to a hosted chat account.

I haven't charged anyone for it.

Demo

Pocket Ledger is live on Render:

Open Pocket Ledger →

You can try the expense ledger directly in the browser.

The app is designed to run locally on your computer.

To run it:

npm install
ollama pull qwen2.5:3b
npm start

Then open:

http://127.0.0.1:3000

If Ollama is not running, the ledger still works. You can choose a category yourself and save the expense.

The app does not download an AI model for you. You install Ollama and the model locally.

Code

davidnize / Side-Hustle

Pocket Ledger

A tiny, local-first expense sorter for freelancers. Add an expense and an open-weight AI model assigns a category and gives a short explanation. Review spending totals, keep a local record, and remove entries when needed.

Why open AI?

Pocket Ledger sends expense descriptions only to the Ollama service running on your own computer. The app does not call a hosted AI API, and the expense ledger is stored in data/expenses.json on that computer. That keeps client and business details out of another company's account, avoids per-request model fees, and lets you change the model with an environment variable. Once the model has been downloaded, categorization can run without an internet connection.

Requirements

Node.js 18 or newer
Ollama installed and running

Run it

npm install
ollama pull qwen2.5:3b
npm start

Then visit http://127.0.0.1:3000.

Ollama is the only AI service used. The first model download requires an internet connection…

View on GitHub

The main parts are:

server.js — the Express server and expense logic
public/ — the frontend
data/expenses.json — the local expense data

The ledger starts with an empty JSON array and stores the expenses on the same computer running the application.

How I Built It

Pocket Ledger is built with Node.js, Express, HTML, CSS, and JavaScript.

There is no hosted AI API.

When Ollama is running, the server sends the expense description and optional merchant to Ollama at:

http://127.0.0.1:11434

The default model is:

qwen2.5:3b

The model is asked to return JSON containing a category and a short note.

The server then checks that the category is one of the seven categories supported by the application.

If Ollama cannot be reached, I choose the category myself from the same list. The expense is still saved, and the app records that the category was chosen manually.

I also added some basic validation around the amount. It has to be a valid positive decimal, and the value stored by the application is rounded to cents.

Why Does Open Innovation Matter?

This is probably the part of the project I care about the most.

The expense description and merchant name stay on my computer. The AI call goes to Ollama running locally on 127.0.0.1.

That means I don't need to send someone's expense details to a closed AI API just to get a category.

Once qwen2.5:3b is downloaded, the categorization can also work without an internet connection.

Another thing I like about using a local model is that the application is not completely tied to one provider. I can point OLLAMA_MODEL at another local model that can return the required JSON without changing the frontend.

And if the AI is unavailable, the actual expense tracker still works.

That was important to me. The AI should help with the job, not become a requirement for the basic ledger.

My First User

I haven't had a paying user yet.

The project is still at the prototype stage, so I don't want to pretend that someone has paid for it when they haven't.

Final Thoughts

Pocket Ledger is a small project, but I wanted it to solve a real problem in a simple way.

The main idea is not just "use AI to categorize expenses."

It is:

Use AI locally when the information being processed doesn't need to leave your computer.

There is still a lot I could improve, but the basic workflow works: enter an expense, categorize it with a local model or manually, save it, and keep the data on your own machine.

That's Pocket Ledger.

Tonight’s Sky: a local Gemma model that tells you when to go outside

David Nizeyimana — Mon, 12 Oct 2026 03:19:01 +0000

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

What I Built

Tonight's Sky is a small web page that tells you when to step outside and look up. It works out today's sunset time and the moon's phase, then a local AI model turns those numbers into a short, friendly tip, like:

Head out a little before sunset at 18:05. It's a new moon, so the sky will get very dark about an hour after, perfect for stargazing. Bring a flashlight.

It's for anyone who keeps meaning to go outside and watch the sky but never knows when. Open the page, read three sentences, and go.

Demo

The top of the image is the night sky I photographed, and the bottom is the app on the same night.

Code

davidnize / touch-grass

🌙 Tonight's Sky

A small web page that tells you when to step outside and look up.

It works out today's sunset time and the moon's phase, then a local AI model (Gemma, running through Ollama) turns those facts into a short, friendly tip:

Head out a little before sunset at 18:05. It's a new moon, so the sky will get very dark about an hour after, perfect for stargazing. Bring a flashlight.

Built for the Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass.

How it works

suncalc calculates sunset, moon phase and moonrise from your coordinates and the clock.
The code turns those numbers into one clear sentence (for example "It is a new moon" or "The moon is 60% full and rises at 20:15").
Gemma (gemma3:1b) writes the tip from that sentence, running locally through Ollama.
Express and EJS show the result on one page.

No…

View on GitHub

How I Built It

Sky math: suncalc calculates sunset, moon phase and moonrise from my coordinates and the clock.
Open-weight AI: Gemma (gemma3:1b) runs locally through Ollama and writes the tip.
App: Node.js with Express, EJS templates and Axios to call Ollama.

The flow is: suncalc produces the facts, my code turns them into one clear sentence (for example "The moon is 60% full and rises at 20:15", or "It is a new moon"), and Gemma writes the tip from that.

Two things I learned along the way:

A small model needs an example, not rules. My first prompts said things like "never say I" and "don't invent details", and Gemma ignored them. One example tip in the prompt fixed the tone and made it include the sunset time.
Check the facts before asking the AI. Early on, it told me to go and see a moon that had set hours earlier. Now my code works out whether the moon is really visible tonight and only gives Gemma true facts.

Why Does Open Innovation Matter?

The whole thing runs on my own computer. With an open-weight model I don't need an API key, an account or a paid plan, and nothing about where I live or when I go outside is sent to a third party. Setup needs the internet once (installing packages, Ollama and the model), and after that the app doesn't call any online service. That suits a project about getting away from screens and connections.

Prize Categories

Best Use of Gemma: every tip on the page is written by Gemma (gemma3:1b), an open-weight model that runs locally on my own computer through Ollama. The app works out the real sunset and moon facts first, and Gemma turns them into a short plan for the reader.

Between Us: a private diary for two people who live far apart

David Nizeyimana — Mon, 05 Oct 2026 04:18:29 +0000

This is a submission for the Hacktoberfest Weekend Challenge: Build for a Friend

What I Built

Between Us is a small private diary for me and my pen pal, someone I've loved for a very long time who now lives far away. We used to talk face to face. Now we write to each other here, in one shared feed, instead of in a chat app. We each log in with a name and a shared passphrase. My entries appear on the right and theirs on the left.

One rule shaped everything: your words stay yours. Entries are saved exactly as typed. The AI never rewrites or "improves" them, because the whole point is to hear each other's real voice.

A local AI adds three small things around the entries:

A question of the day in the entry box, in case you don't know where to start.
A verse in the header each day.
A short recap every Saturday night, written by Gemma and marked as AI-written. Sunday to Friday, there is no recap.

Demo

Code

davidnize / build-for-a-friend

Between Us

Scars leave beautiful traces.

A small private diary for two people who used to talk face to face and now live far apart. Each of you writes entries, and you read each other's in one shared feed.

Built for the Hacktoberfest Weekend Challenge: Build for a Friend.

What it does

Your words stay yours. Entries are saved exactly as you type them. No AI rewrites or edits them.
A question of the day. The grey placeholder in the entry box is a short question, written fresh each day by Gemma. You can answer it or write about something else.
"This week between us." Every Saturday at 9 pm, Gemma reads the week's entries and writes a short recap. It is always labelled as AI-written, so it is never confused with your own words.
Private. You log in with your name and a shared passphrase.
Your entries on…

View on GitHub

How I Built It

The app is Node.js and Express, with EJS templates, plain CSS and PostgreSQL. The AI is Gemma 3, an open-weight model, running locally through Ollama. Nothing is sent to an AI service.

Gemma does three jobs:

Questions. It writes a fresh question each day. After someone posts, it writes the next question for that person in the background. A backup question shows up instantly, so nobody waits for the model.
Verses. Gemma only picks a reference, like Psalm 34:18. The text itself comes from a Bible API, so the model never writes scripture.
Recaps. Every Saturday at 9 pm, it reads the week's entries and writes a short recap. The prompt tells it not to invent anything, give advice, or rewrite anyone's words.

Background jobs run when the server starts and every 15 minutes after that, so if my computer was off at the scheduled time, the missing question, verse or recap is created when it's back on.

Why Does Open Innovation Matter?

A diary is the most private thing you can write, and this one is between two people. Running an open-weight model on my own computer means the entries never leave it. A closed API would have meant sending our private words to a server I don't control just to get a recap.

It also costs nothing to run and needs no account or API key. And because the model is a single setting (ollamaModel), I can swap it for another one by changing one line.

To be exact about what goes online: the only outside request is the verse lookup, and it contains a Bible reference, never anything we wrote.