DEV Community: JUKUN MAN WITH SME POWER

Sloth Tidy: a folder sorter that runs on my own gemma3, offline.

JUKUN MAN WITH SME POWER — Mon, 26 Oct 2026 01:52:12 +0000

Sloth Tidy sorts and renames a messy folder for you. Point it at Downloads or Desktop and it proposes moves like Untitled1.txt -> documents/standup-notes.txt, based on what the file actually says, not just its extension.
It is lazy-friendly by design:

Dry run by default. Nothing moves until you click Apply.
Never overwrites a file (name clashes get -2, -3).
One-click undo puts everything back.

There is a command-line tool and a small local web page (python ui.py) with Preview, Apply and Undo buttons. I'd never organise my Downloads folder myself, so now I don't have to.

AliFikan94 / hacktober3

Sloth Tidy

Point it at a messy folder. It sorts and renames everything using a local open-weight model (via Ollama). Nothing leaves your machine. Python stdlib only.

ollama pull gemma3:4b          # any open-weight model works (gemma3:1b is faster)
python3 sloth.py ~/Downloads             # dry run: shows what it would do
python3 sloth.py ~/Downloads --apply     # do it
python3 sloth.py ~/Downloads --undo      # change your mind

Prefer clicking? python ui.py opens a small local web page (preview, apply, undo). It listens on 127.0.0.1 only.

IMG_0042.JPG becomes images/img-0042.jpg. Untitled(3).txt containing meeting notes becomes documents/team-standup-notes.txt.

How it works

For each file, sends the filename plus the first 600 characters (text files only) to the local model and asks for JSON: {category, name}.
Output is validated; a bad answer or an unreachable server falls back to extension rules, so it never hangs or breaks.
Safe by default: dry…

View on GitHub

Two files sorted by their content, using gemma3:1b on my own CPU:

PS> python sloth.py $HOME\mini --model gemma3:1b
(first file may be slow while gemma3:1b loads)
[1/2] note2.txt ...
[2/2] Untitled1.txt ...
note2.txt  ->  documents\groceries-list.txt
Untitled1.txt  ->  documents\standup-notes.txt
dry run: 2 files. add --apply to do it.

AliFikan94 / hacktober3

Sloth Tidy

Point it at a messy folder. It sorts and renames everything using a local open-weight model (via Ollama). Nothing leaves your machine. Python stdlib only.

ollama pull gemma3:4b          # any open-weight model works (gemma3:1b is faster)
python3 sloth.py ~/Downloads             # dry run: shows what it would do
python3 sloth.py ~/Downloads --apply     # do it
python3 sloth.py ~/Downloads --undo      # change your mind

Prefer clicking? python ui.py opens a small local web page (preview, apply, undo). It listens on 127.0.0.1 only.

IMG_0042.JPG becomes images/img-0042.jpg. Untitled(3).txt containing meeting notes becomes documents/team-standup-notes.txt.

How it works

For each file, sends the filename plus the first 600 characters (text files only) to the local model and asks for JSON: {category, name}.
Output is validated; a bad answer or an unreachable server falls back to extension rules, so it never hangs or breaks.
Safe by default: dry…

View on GitHub

Model: Google's open-weight gemma3 (1B and 4B), served locally by Ollama. I already had it installed, so setup took no time and no new downloads.
Tool: plain Python, standard library only, no dependencies. For each file it sends the filename and the first 600 characters of text files to the local model and asks for JSON ({category, name}).
Guardrails: the model's answer is validated. If Ollama is down, slow, or returns something unusable, the tool falls back to simple extension rules instead of hanging or crashing.
Safety: a dry run first, collision-proof names, and an undo log.
UI: a tiny local web page built with the standard library, listening on 127.0.0.1 only. (https://dev-to-uploads.s3.us-east-2.amazonaws.com/uploads/articles/0q5vy393kwmp75oztr4z.png)

A folder tidier has to read your private files: tax returns, chat exports, notes. With an open-weight model on localhost, those contents never leave my machine, it works with no internet connection, and it costs nothing per file.

It is also swappable. --model accepts any Ollama model, so I could try gemma3:1b for speed and gemma3:4b for quality by changing one flag. With a closed API I would be uploading my Downloads folder to someone else's server and paying per file.
(https://dev-to-uploads.s3.us-east-2.amazonaws.com/uploads/articles/rml016bakg4swrv7fwqx.png)

The Lazy Payoff

It names files by their content without me opening them, and my files stay on my PC. Honest notes from building it:

My first run named both files other.txt. Two causes: Windows PowerShell saves text files as UTF-16, which my code read as garbage, and a 1B model sometimes copies words from the prompt. Decoding UTF-16 properly and giving the model a clearer example fixed it.
It runs on CPU, so it is slow per file. A small model suits a one-off tidy or an overnight run, not instant results.
It never gets stuck. Without a working model, it still sorts by extension.

Prize Categories

Open-weight models / local inference.

Nobody Has Startup Cash. Everybody Has a Skill.

JUKUN MAN WITH SME POWER — Mon, 19 Oct 2026 02:53:15 +0000

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

Your side hustle doesn't have a budget problem. It has a missing skill problem.

You've got the idea. You've got the weekends. What you don't have is a logo, a landing page, or someone to explain Python to you, and no cash to buy any of it.

Meanwhile, the person who could do that logo in an hour needs exactly what you know.

SkillSwap connects the two of you. Then it goes further.

How I got there

Understand. A side hustle runs on nights and weekends. The people running one are time-poor and cash-poor, but skill-rich. The wall they hit is rarely the idea. It's the one skill they don't have, and the money to buy it.

Observe. Look at how people patch that gap today: asking favours in group chats, paying a freelancer they can't really afford, or attempting a one-to-one trade that only works when two people happen to need each other's exact thing. Clean matches are the exception.

Redefine. The question changed from "how do I find a cheaper freelancer?" to "how might skills pay for skills, even when the trade isn't between two people?" One sentence, and the whole product shifted from a marketplace to a graph.

Ideate, with Claude. I used Claude as a sparring partner: marketplace, time-credit currency, graph matching, which wins? We kept all three in order of preference (swaps, then loops, then credits as a safety net). Claude also found the flaw that shaped the AI half of the project: "figma" and "ui design" are different strings, so exact matching would miss the very people who most need each other.

Prototype. FastAPI and SQLite, a graph search for swaps and loops, real accounts, and an interface that feels like it belongs on a Mac, dark mode included. Built with Claude Code.

Test. 17 automated tests, plus driving the real app in a browser from sign-up to booking to review. That caught things I'd have happily shipped: a phone layout that fell apart, ratings that didn't refresh, and a loop card that cheerfully announced "You teaches Ben." One honest caveat: the similarity threshold for fuzzy matches is a starting point, not something I've tuned on real users yet.

The open-source part isn't decoration. It's the engine.

Type "ui design" and the best teacher on the network might list "figma". Matching those takes meaning, not string equality.

So SkillSwap embeds every skill with Gemma's embedding model (embeddinggemma), running through Ollama on your own machine, and matches by similarity. The result shows up right in the interface:

Why local and open matters here:

Privacy. A skill profile is a list of what you can't do yet. That's personal. It never leaves your laptop.
Cost. No API bill, for a project about not having cash.
Control. Swap the model with one environment variable. Tune the threshold. Change the behaviour.
Resilience. No model running? The app falls back to exact matching and keeps working.

Try it

Code: AliFikan94/skillswap

git clone https://github.com/AliFikan94/skillswap.git && cd skillswap
git checkout claude/eloquent-gates-c2q636
pip install -r requirements.txt && python -m app.seed
ollama pull embeddinggemma            # optional: semantic matching
SKILLSWAP_OLLAMA_URL=http://localhost:11434 uvicorn app.main:app

What's next

Real scheduling, in-app chat, and a notification the moment a new loop closes around you.

Because the best side hustle advice might just be this: you don't need a budget. You need the right two other people.

LFG!!!!!

JUKUN MAN WITH SME POWER — Sun, 11 Oct 2026 17:16:39 +0000

Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass Submission 🌿

JUKUN MAN WITH SME POWER

Oct 11

Built Blade, an app to get you off your screen, one walk proved it wrong about the rain.

#devchallenge #hf26challenge #mlhacks

6 min read

Built Blade, an app to get you off your screen, one walk proved it wrong about the rain.

JUKUN MAN WITH SME POWER — Sun, 11 Oct 2026 17:16:04 +0000

https://github.com/AliFikan94/touchGrass
`
This is a submission for the Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass

Your phone will still be there when you get back!

What I Built

It's called Blade. You tell it how long you've got and where you are, and it gives you one small daily task: a walk, plus a couple of things to notice. Then it tells you to put the phone away. That last line is the whole product. The screen exists to hand you a card and get out of your way.

There's a streak, but a gentle one. Skip a day and it says "No streak pressure. Just step outside when you can." I did think about a leaderboard for about ten minutes and then dropped it. Ranking people on how much they went outside felt like the fastest way to make going outside miserable, and it would need a server holding everyone's data, which is the opposite of why I picked open models.

Demo

You won't find walk photos in this post, and that's deliberate. The card said to put the phone away, so I did. The only camera I used was my eyes.

Here's what you get instead. This is a real card from my own machine:

Move.
  Walk for 15 minutes without stopping.

Notice.
  - Find evidence of an animal: a feather, a nest, tracks, chewed leaves.
  - See or hear three different birds.

Phone away. The grass is waiting.

The flow in the browser: pick how long you've got and what you feel like noticing, set your place (your browser can find it, or you type the coordinates), and press one button. A card appears with tick boxes. You close the laptop and go. When you're back, you press "Blade complete", and a small box asks what you noticed.

Blade runs on your own machine, so there's no hosted link. That's on purpose. To try it: install Ollama, then ollama pull gemma3:1b and python main.py.
https://github.com/AliFikan94/touchGrass

Code

How I Built It

The open piece is Gemma, running locally through Ollama. It writes the card. The rest is plain Python and one HTML page, with no framework, no keys and no accounts.

One rule shaped everything: the model never gets to decide a fact. Season, daylight left and climate are worked out in ordinary code from your latitude and the date. Gemma gets a task and a short menu of real observations, and its only job is to phrase them nicely. A small model will confidently tell you about a bird that doesn't exist, so I just don't give it the chance.

Here's how the day went.

I typed python main.py and there was no main.py. Fair. It was a package. I added one so nobody else does the same.

The app said [fallback] and wouldn't tell me why. Blade is built to serve a preset card when the model isn't available, so it never breaks. The catch is that it did this silently, so on my first real run I got a perfectly nice card and no idea whether Gemma had written it. I made it admit the reason, and the reason was this:

model requires more system memory (4.0 GiB) than is available (2.5 GiB)

My machine couldn't load the 4B model. I switched to the 1B model with one setting, and it worked. I'll come back to why that matters.

Then it just spun. "Listening to the grass..." for minutes, with nothing else happening. A small machine can take a long time to load a model on the first request, and I'd given it three minutes and no feedback. The fix was boring and effective: warm the model up when the server starts, cap how much it's allowed to write, give up after 60 seconds with the reason shown, and put a seconds counter on the screen so you know it's alive.

Then I broke git. I'd committed Python's cache files to the repo by accident, and the next git pull refused to run. Very much the deadline-day energy.

Then I fixed the seasons. Lagos doesn't do autumn. Neither does anywhere near the equator, and a naive "it's October, so leaves are turning" gets that completely wrong. So Blade works out a climate band from your latitude and knows the tropics are a different deal.

I also added an opt-in switch that looks up the real local weather and what other people have recorded nearby on iNaturalist, so a task can say "look for a Northern Cardinal, someone saw one near here this week". It's off by default, it rounds your location to about a kilometre before sending anything, and with no network it quietly gives you the offline card. Those species names come from real records, never from the model.

Forty-one tests later, I finally went outside.

I went out from 4:01 to 4:28 pm in Lagos, Nigeria. Twenty-seven minutes. I followed the rules on the card: I did the tasks, and the phone stayed away. The card said:

Walk to the nearest park.
Watch rain on leaves. Listen to it.
See or hear different birds.

There was no rain.

Not a drop. The app had cheerfully told me to go and listen to rain that wasn't happening. Without the weather lookup on, Blade has no idea what the sky is doing, and I'd never told it that rain tasks should wait for actual rain. I'd tested the logic. I had not tested the world. A real walk found in 27 minutes what a pile of tests didn't. Rain tasks now only appear when the weather says rain, there's a test for a dry day in Lagos, and while I was in there I stopped it from suggesting frost patterns in warm places too.

What I actually noticed had nothing to do with the card: a dove, a pelican and a mango tree.

I came home, pressed "Blade complete", and the app said... "Blade complete." That's it. I'd just seen a pelican and my app had the emotional range of a vending machine.

So I added one more thing. After you finish, there's now a small box: What did you notice? You type a few words and Gemma answers in a line or two. It only ever sees what you wrote, it can't add animals you didn't mention, and if its answer rambles or turns into a question it gets thrown out for a plain fixed line.

I typed in "a dove, a pelican, a mango tree". It said:

Why Does Open Innovation Matter?

This isn't a slogan for me, because the day gave me real examples.

When my laptop couldn't load the 4B model, I changed one setting and used a smaller one. With a closed API there's no smaller one to fall back to. You pay, or you don't.

Most of the app works with no signal, because the sun maths and the climate logic are just code on your machine and the model runs locally. A park with no coverage is exactly where this should work.

And my location stays on my laptop. The one optional feature that does phone out says so in plain words, and rounds the location first. There's no key, no account and nothing to pay for.

Where a closed model would have won: Gemma 1B writes plainer than a big frontier model. That's why I fenced it in so hard, with a menu of real tasks, validated output and a fallback. For a card you read in ten seconds before you leave the house, I'd make that trade again.

Prize Categories

Best Use of Gemma: Gemma, run locally through Ollama, writes every card and every reply.

Step outside. Touch a blade. Notice the world.

[Boost]

JUKUN MAN WITH SME POWER — Mon, 05 Oct 2026 05:15:14 +0000

JUKUN MAN WITH SME POWER

Oct 5

TeachBack: You don't know it, until you can teach it back!

#devchallenge #weekendchallenge #hf26challenge

4 min read

TeachBack: You don't know it, until you can teach it back!

JUKUN MAN WITH SME POWER — Mon, 05 Oct 2026 05:14:51 +0000

Built for a friend learning Python after exhausting shifts at an electricity distribution company.

The Friend & The Friction

My buddy works a grueling 9 to 5 at a local electricity distribution company. He's been trying to break into Python, but he's trapped in the classic "tutorial hell": endless YouTube playlists, passive video watching, and synthetic projects like "build a calculator" that have zero relevance to his actual life.

We kept promising each other we'd jump on Discord for study sessions, but life kept getting in the way. By the time he finishes dealing with feeder voltages, blackout reports, and transformer glitches, he's drained and barely has the energy to look at a keyboard, let alone schedule a live call. Our working hours almost never aligned. I realized he needed something he could run entirely on his own schedule: a self paced learning tool that could act as a live study partner without needing me (or anyone else) on the other end of a call.

The Spark & The Idea

Around the same time, I applied to teach for Stanford's Code in Place. As part of the application, they had me teach a simulated classroom of three virtual students who watched my screen, listened, and asked sharp questions.

It clicked: the fastest way to figure out if you actually understand something isn't reading about it, it's explaining it to someone else.

Most platforms follow a rigid pipeline:
Theory
⬇️
Practice
⬇️
Workshop.
But passive comprehension is a trap; you think you get it until you try to say it out loud. I wanted to add the crucial missing fourth step: "Teach."

What I Built

TeachBack is a lightweight learning platform you use in the browser, run from a small local server on your own computer. It's tailored to my friend's reality:

8 tailored lessons using data from his world: meter readings, line loads, and outage priorities.

In-browser Python, so there's no Python installation to wrestle with after an 8-hour shift.
The "Teach" phase: instead of a quiz, he explains the code to three distinct AI students:
- Maya: the curious one who always asks why.
- Kofi: the edge-case guy who asks what breaks when inputs go sideways.
- Zee: the beginner who needs everything in plain, simple words.
An objective examiner: a second AI agent that reads what he says (as text) and checks whether he explained each core idea in his own words. If it can't point to words he actually said, the explanation is rejected.
The Capstone: his final project is to design his own certificate in Python. Once he builds it and teaches the code back, the app shows the certificate he made.

AliFikan94 / hacktober26

🎓 TeachBack

Honest status (hackathon submission). TeachBack's lessons, in-browser Python runner, capstone, certificate, model picker, privacy panel and the Teach logic (students, examiner, voice loop) are implemented and covered by automated tests and browser tests against simulated model servers. On the author's low-memory PC (about 2.5 GB free RAM) the Teach conversation was not verified end to end with a real local Gemma before the deadline, and its cause was not pinned down. The in-app Test the students and Test the microphone buttons (model menu, top right) and npm run doctor exist to diagnose exactly that. It has not been tested by the friend it was built for.

Theory → Practice → Workshop → Teach. A learn-and-teach platform built for a friend who works 9–5 at an electricity distribution company, wants to learn Python, and is too tired to type after work.

Each lesson has four phases: 📖 Theory…

View on GitHub

Repository: github.com/AliFikan94/hacktober26

How I Built It

Open-source AI and tools

Open-weight models through Ollama running locally. My target was Gemma 3 (I pulled gemma3:4b and gemma3:1b), reached through Ollama's OpenAI-compatible endpoint.
Mastra for the agents: four of them (Maya, Kofi, Zee and the examiner), each with its own instructions. A simple rule picks which student speaks, based on what the learner just said.
Pyodide (Python compiled to WebAssembly) so Python runs inside the page.
A small TypeScript/Node server streams each student's reply to the browser as soon as it's ready. The browser's built-in speech tools handle voice.

How the examiner stays honest: it must quote the learner's own words as evidence, and the server rejects any quote that isn't really in what they said. If a small model can't answer in the required format, a labelled keyword check takes over.

Built with AI assistance: I built this with an AI coding assistant (Claude Code), working under my direction.

The Honest Part: What Didn't Work

I'm submitting this with complete honesty about its rough edges:

Hardware constraints: A 4B Gemma model needs around 4 GB of free RAM, but my test PC only had about 2.5 GB. I built an automatic memory check that steps down to a smaller model, or to a cloud model (and says so), when hardware is tight.
Small model formatting: Tiny local models love to answer in paragraphs instead of structured JSON. Hence the fallback keyword check.
Voice fragility: Browser speech recognition behaves differently across platforms. I added microphone diagnostics with plain-English error messages.
End-to-end testing: The Teach system passes automated tests against simulated models, but I couldn't get the full local conversation working on my low-spec machine before the deadline. My friend also hasn't done a full run-through yet, so I don't have a quote from him... yet!

What I Learned

Building an AI tool for a real person with a real job and real hardware limits is humbling. The hard part wasn't writing prompts, it was making open-source AI light enough to run on an everyday laptop. Next: a lightweight hosted option for low-spec hardware, and getting my friend into a live session to test his outage-priority scripts.

Why Does Open Innovation Matter?

For a tired adult learner who is learning in the evenings, open models matter in three ways:

Privacy: his half-baked logic and "dumb questions" can stay on his own machine. (Browser voice recognition in Chrome and Edge sends audio to external servers, so the app tells you plainly that typing is the fully private option.)
Cost: a local model costs nothing to run every evening.
Control: I can tune the students' personalities and the examiner's rules by editing prompts, which gives me far more control than a closed, rigid chatbot. I could also swap the model with one setting, which is exactly what let me adapt when my PC couldn't run the first one.

Prize Categories

Best Use of Mastra: four Mastra agents drive the students and the examiner.

(Gemma was my target model, but I couldn't show it running end to end, so I'm not entering that category.)

GM GM devs

JUKUN MAN WITH SME POWER — Thu, 30 Jul 2026 10:43:05 +0000

GM GM guys, what are you buidling???

JUKUN MAN WITH SME POWER — Tue, 14 Jul 2026 18:56:48 +0000

https://dev.to/thisisfeekey/tyson-knockout-audio-for-solo-creators-without-the-300-hardware-weekend-challenge-5dj8

JUKUN MAN WITH SME POWER — Mon, 13 Jul 2026 05:49:28 +0000

JUKUN MAN WITH SME POWER

Jul 13

🥊 Tyson: Knockout Audio for Solo Creators (Without the $300 Hardware) | Weekend Challenge

3 min read

My Debut #weekendchallenge

JUKUN MAN WITH SME POWER — Mon, 13 Jul 2026 05:48:06 +0000

JUKUN MAN WITH SME POWER

Jul 13

🥊 Tyson: Knockout Audio for Solo Creators (Without the $300 Hardware) | Weekend Challenge

3 min read

🥊 Tyson: Knockout Audio for Solo Creators (Without the $300 Hardware) | Weekend Challenge

JUKUN MAN WITH SME POWER — Mon, 13 Jul 2026 05:38:01 +0000

🥊 Tyson - The Wireless Phone Mic App That Packs a Punch

This is a submission for the Weekend Challenge!

🎙️ What I Built
Let’s be honest: solo content creators are tired of holding their secondary phones awkwardly like makeshift reporter mics or spending $300+ on bulky wireless lavalier setups that require dongles, cases, and endless charging cables.

Enter Tyson (a.k.a. Tai Sun). It's a cross-platform Flutter app designed to turn the smartphone you already own into a dedicated, heavy-hitting wireless microphone system.

By separating the workflow into a dual-device ecosystem, Tyson lets you use one phone as the sharp Camera/Director angle and a second phone as the high-fidelity Mic, delivering studio-quality sound directly from your pocket.

⚡ Key Features (The Heavy Hitters)
Dual-Device Ecosystem: Dedicated Mic Mode (with absolute UI lock to prevent accidental palm-touches) and Camera Mode layout.

Smart Environmental Presets: Instant switching between Indoor and Outdoor profiles. Outdoor mode activates automatic noise gating and suppression to fight ambient chaos (like traffic or wind noise).

Custom Voice Profiles: Tailor your sound signature on the fly with Clean, Voice, Podcast, and Warm DSP configurations.

Seamless QR & Room Code Pairing: Zero-friction device discovery, laying the groundwork for automatic local Hotspot/WebSocket connectivity.

Simulated "Stop & Mux" Flow: Hits the absolute biggest pain point in filmmaking. Once you hit stop, the mic phone automatically simulates background file transfer to the camera phone for instant track alignment.

💡 Inspiration
I was watching creators shoot content and noticed a painful pattern: people either sounded like they were recording inside a tin can, or they looked ridiculous shouting into a phone held two inches from their mouth. Flagsip phones have insane microphone hardware built right into them, yet no one was utilizing it as a standalone, smart wireless receiver.

I decided to build an underdog app that bites the noise right out of your audio—hence the name Tyson.

The Climax: Hitting Stop 🛑 and watching the app automatically package and transfer the audio file to the Director phone.

Live Demo: Want to take it for a spin? The Android APK is built and ready in the repository releases.

🛠️ How I Built It
Tyson was built entirely from scratch over the weekend using a nimble, high-performance stack:

Framework: Flutter (Dart) – Compiled down to native ARM code to keep audio buffer latency tight and UI fluid across iOS and Android.

Audio Capture: The record package, heavily modified with custom system presets for noise suppression and hardware gain control.

Playback Engine: audioplayers for crisp local audio verification.

Pairing UI: qr_flutter for instant cross-device handshake generation.

🏗️ Core Architecture
MIC Transmitter Mode: Background-priority capture state optimized to save battery and reduce thermal throttling while processing real-time audio.

CAMERA Receiver Mode: A dedicated placeholder interface designed to display received audio metadata and eventual video preview syncing.

🥊 Challenges & Knockouts
The Camera Plugin Brawl: The native Flutter camera plugin decided to throw a temper tantrum on my environment configuration during the crunch window. Instead of getting stuck in dependency hell, I pivoted like a pro—focusing 100% of my energy on perfecting the core audio processing, DSP presets, and wireless transfer UX.

Taming the Noise: Getting standard mobile audio APIs to reliably separate background hiss from real human voice without heavy delay took some intense fine-tuning.

🧠 What I Learned
How to handle low-level device audio streams and apply real-time operating system filters without killing the device's battery.

Designing state architecture that cleanly handles simulated network data flows so the code is structurally ready for live WebSockets/UDP streaming next.

Huge thanks to the organizers for putting together this weekend challenge! Time to go refresh the GitHub repo and get back to building. 🥊

GitHub Repository: github.com/AliFikan94/Tyson

weekendchallenge #devchallenge #flutter #mobile #audio