DEV Community: Dennys A

SkillWalk - approve the tutorial, then watch it work

Dennys A — Mon, 26 Oct 2026 06:38:49 +0000

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

What I Built

You find an AI tutorial you want to try. Then come the pauses: find the repository, set up the tools, follow along, and figure out why your result looks different. Another useful video joins the "I'll try this later" collection.

I built SkillWalk for that moment.

It turns three reviewed YouTube tutorials into local workflows you can watch. Confirm the video, review the analysis, and approve execution. From there, it runs the supported steps, checks the result in a real browser, attempts bounded repairs when checks fail, and delivers the checked output without another required click. Stop remains available.

The main tutorial produces a PDF question-answering app. Presentation and frontend-design tutorials are also available.

You can paste your own YouTube link to check whether SkillWalk supports it. Currently, execution is available for three reviewed tutorials; other links are preview-only. SkillWalk uses local Gemma models, so tutorials designed around frontier Claude or OpenAI models may produce different results or require capabilities this version doesn't support.

Demo

Watch on YouTube. This animated promo illustrates SkillWalk's workflow.

The built-in document run needs no writing or upload. SkillWalk supplies a labelled synthetic PDF, opens the resulting app, and tests questions against its table and chart.

In the application, local model work, actual browser activity and the finished app are shown as distinct stages. Afterwards, you can ask your own questions, download the checked source, or use Try it yourself to follow the original tutorial independently.

SkillWalk runs locally; there is no hosted app.

Code

SkillWalk on GitHub

The repository includes the MIT-licensed application and local setup instructions.

How I Built It

The document workflow follows Nariman Codes' tutorial and its MIT-licensed source.

Local Gemma interprets the actual video captions, sampled frames and source materials, then produces configuration instructions. Reviewed adapters run the supported steps instead of executing commands taken from video text.

The app extracts PDF text, tables and images. Gemma 3 4B describes visual content and answers questions; EmbeddingGemma supports local retrieval. Node coordinates the workflow, Streamlit provides the resulting app, and Playwright checks it inside an isolated local Docker runtime.

The result is a working local app where you can ask questions about a PDF, see the retrieved source passages, and try your own document after the automatic run finishes. The checked source is available to download so you can inspect or adapt the workflow.

Why Does Open Innovation Matter?

SkillWalk builds on reusable source code and runs its model inference on your own computer. It needs no paid model API or model-service key, and PDF contents are not sent to a hosted inference provider. Instructions and code are available to inspect and adapt.

That makes repeated attempts possible without a per-request model bill. Hardware, electricity and setup still have costs. YouTube and initial downloads need internet access.

There are tradeoffs: the document video demonstrates a larger Gemma model, while the other two tutorials demonstrate Claude. This local adaptation does not promise the same appearance or answer quality.

The Lazy Payoff

Instead of pausing, rewinding and following every step yourself, give SkillWalk a supported YouTube tutorial. It analyzes the video and prepares a plan. Approve it, then sit back and watch the workflow run—from creating the result to testing it and making supported repairs.

When it finishes, explore what it made or download the source to try it yourself.

Prize Categories

Best Use of Gemma: local Gemma performs source interpretation and configuration, image/table description and document answers. EmbeddingGemma supports retrieval. These are working parts of the product, rather than an added summary.

Roolin: rehearse the unexpected before opening night

Dennys A — Mon, 19 Oct 2026 05:20:01 +0000

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

What I Built

It is 19:03 on the night of the school showcase. The soloist is not in the wings. The host is looking at you, the audience is looking at the curtain, and you have about a minute to say something to the crew that does not make it worse.

Roolin is a local 3D rehearsal room for that minute.

It gives teachers, stage managers and community-theatre organisers somewhere to practise responding when a microphone fails or a performer is late. A theatre volunteer should not need to understand AI or programming to practise a difficult moment. Once the local setup is complete, the app guides them through the running order, their response and the next thing to check.

Bring your running order, review the cues proposed by Gemma, and explore a representative theatre—from the audience to backstage. At a cue, choose a disruption and write what you would actually tell the team. Gemma responds to your words with coaching and a concrete next check.

For example, when the soloist is late, you can practise briefing the crew and holding the show. Accepting that hold moves the current and later cues by five minutes while preserving the original schedule. Using a reported tested spare microphone leaves the times unchanged.

Preparation helps you work backwards from the first cue to decide when setup should begin.

The potential paid direction is team plans for drama departments and small production companies: shared running orders, collaborative rehearsals and crew-ready handoffs. Those are future possibilities. I’ve spoken with different people about whether this is something they would pay for; those conversations are exploratory, rather than confirmed purchases.

Demo

Watch the Roolin demo on YouTube

“The Show Before the Show” follows a fictional theatre volunteer facing a late soloist. Product scenes show the real Roolin app running with local Gemma and demonstrate how the rehearsal flow works.

Code

Roolin on GitHub

The application is MIT-licensed and runs locally. The README covers installation, model setup and limitations.

How I Built It

I built the theatre with Three.js, alongside a JavaScript interface and a local Node server.

Gemma 4 E4B, running through Ollama, handles two jobs: turning plain-text show notes into proposed cues with source quotations, and coaching written responses to disruptions.

Application code checks cue times, quoted text and valid schedule changes. The organiser reviews the results and approves changes.

All 18 automated tests pass, and separate browser walkthroughs exercised real local inference. AI tools assisted development and demo production.

This is a single-user prototype with two simulated disruptions. It does not detect equipment failures or certify readiness. Session data disappears on refresh; export it first.

Why Does Open Innovation Matter?

A lot of useful technology comes with another payment or subscription. Sometimes, you can build what you need yourself using open tools and a computer you already have at home.

That is what I wanted to explore with Roolin. With suitable hardware, open weights and local inference make it possible to create a rehearsal tool without paying a cloud provider for every practice session. Hardware, electricity and initial setup still have a cost.

The person using it does not have to be the person who built it. A theatre volunteer can focus on what they would say to the crew and how to respond to a disruption, while the app provides a place to practise and review the consequences. Making those tools available to people who are not tech savvy is part of the value I want to test.

Local inference also lets rehearsal notes stay on the organiser’s computer. The application code, prompts and validation rules are available for others to inspect and adapt to their own productions.

Prize Categories

Best Use of Gemma: local Gemma powers source-linked cue drafting and response coaching—the two language tasks at the heart of Roolin.

Sidewalk Senate: go for a walk, then let a local Gemma help you write to the people redesigning your street

Dennys A — Sun, 11 Oct 2026 21:52:21 +0000

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

What I Built

Somewhere in a city PDF, someone has already redrawn the corner you walk past every day. In March 2026, NYC DOT presented a plan for Court Square in Long Island City, Queens: wider sidewalks on Thomson Avenue, new pedestrian crossings, a raised shared street. The people who know whether that corner feels crowded are the people walking it. Almost none of them will ever open that PDF.

Sidewalk Senate is a small, local-first notebook that sits on either side of an ordinary outing.

Before you go (optional). Type one line about where you're headed. Press I'm heading out, and the app answers: "That's enough screen time." The map disappears. There is nothing to record and nothing tracking you.
Go outside. Get coffee, walk with a friend, sit somewhere. No GPS, no photos, no check-ins. The outing is the point.
When you're back. Write down where you spent time and how it felt, in your own words. If the place matches one of the curated locations, you confirm it yourself. The app never guesses where you were.
Find the connection. A local open-weight model (Gemma 4) reads your reflection next to a dated public proposal and suggests where your experience fits. It cites the exact page, and everything it writes is labelled AI interpretation · Review required. Your original words are shown separately and never rewritten.
Shape your suggestion. Edit the AI's suggested question or write your own, tick "I've reviewed these words," and format an unsent draft. Nothing is ever sent. That part stays with you.

If the place you visited has no reviewed proposal, it says so plainly ("Your thought still belongs here") instead of borrowing a nearby project to look helpful.

Who it's for: residents who already walk their neighborhood and have opinions about it, but who will never attend a community board meeting or read a long design presentation. The screen is the shortest part of the experience: a line before you leave, a few sentences when you get back.

The first pilot area is ZIP 11101 (Long Island City, Queens), with one curated, page-cited source: NYC DOT's Court Square Pedestrian Improvements, March 2026.

Demo

Watch the 2-minute Sidewalk Senate demo on YouTube

Prefer a file? The same video and its captions are attached to a GitHub release.

The video is a fictional outing run through the real app: every app screen is the real local website, and the connection, page citation and draft are real output from Gemma 4 running on my own computer. The outing and the reflection are simulated, which the video says at the start and on the end card. The outdoor shots are stock footage from Pexels (Keira Burton and Coverr), not my walk. The model's 21-second wait is shown faster, with the real time on screen. Even the soundtrack stayed local and open: narration by Kokoro-82M and music generated with Meta's MusicGen-small.

Code

antunishdPursuit / SidewalkSenate

A local Gemma-powered civic notebook connecting everyday outings with dated public-space proposals and unsent resident suggestions.

Sidewalk Senate

A new local-first prototype connecting everyday outings with dated public-space proposals and resident suggestions.

Source repository · Download source ZIP

Current scope

A local website with two notebook workspaces: My outing and Connection & draft. A local API and an optional interactive terminal session support the same source-backed workflow. Current coverage is one curated Court Square project with three reference intersections. Other places can still support a resident-written suggestion without an invented proposal match.

No tracking, Gmail, email sending, account connection, live search, analytics or persistent reflection storage is implemented. Nothing here establishes present street conditions or an open consultation. The website is intended to be used briefly before or after an ordinary outing; it requires no phone use or recording while outside.

Requires Node.js 24+. Run npm ci to install the frontend dependencies. No paid API is required.

npm ci
npm test
npm run check
npm

…

View on GitHub

Sidewalk Senate source code on GitHub (MIT-licensed; the README covers setup, the pinned model, privacy boundaries and known limits).

Run it locally (Node.js 24+, no paid API):

npm run setup
npm run local

Then open http://127.0.0.1:4178. npm run doctor checks dependencies and the model service; npm run simulate runs a labelled two-stop outing through the real HTTP handlers with mock AI, and npm run simulate:real runs the same outing against real local Gemma.

How I Built It

The model. Gemma 4 E4B Instruct, the Q4_0 GGUF from ggml-org/gemma-4-E4B-it-GGUF (pinned revision and SHA256 in the README), imported into Ollama as local-gemma with a 4096-token context. The app calls Ollama's OpenAI-compatible chat endpoint on 127.0.0.1:11434. That's it: no cloud endpoint is accepted. The URL validator rejects anything that isn't a loopback HTTP address.

The architecture.

Browser notebook (React + Vite + TypeScript, Leaflet map)
   │  same-origin, loopback only
   ▼
Local Node API (/api/cases, /api/reflect, /api/draft)
   │  validated JSON in, validated JSON out
   ▼
Ollama · Gemma 4 E4B (open weights, on this computer)

Keeping a small model honest. The interesting work wasn't the prompt; it was everything around it.

Schema-constrained output. Gemma answers through a strict JSON schema (summary, connections, suggestion, open questions), at temperature 0.2 with a bounded output budget. A response cut off by the length limit is rejected instead of half-parsed.
The model can only cite what a person reviewed. Each curated source is broken into short claims with a page number. Gemma may only refer to claims by ID; the server rejects any unknown or duplicate ID and builds the citation link (...#page=17) itself, so the model can't invent a page.

const allowed = new Set(context.claims.map(c => c.id));
const connections = raw.connections.map(c => {
  if (!c || !allowed.has(c.claimId) || seen.has(c.claimId))
    throw new InputError('Unsupported or duplicate source claim.');
  const claim = context.claims.find(item => item.id === c.claimId);
  return { claimId: c.claimId, explanation: text(c.explanation, 'Connection', 1200),
           sourceClaim: claim.text, citation: context.source.url + '#page=' + claim.page };
});

The resident confirms the place, not the model. A ZIP code or a nearby pin never decides relevance. If you pick a curated location, you have to tick "I visited this location" before any connection is attempted. An unconfirmed or unknown place returns a no-match without calling the model at all.
Feelings stay feelings. In testing, one response turned a resident feeling hurried at a crossing into a claim about inadequate signal timing. So the model-written rationale is now replaced with a fixed line: based on your personal reflection, not verified street conditions or an engineering assessment. The prompt also tells it to keep satisfaction as satisfaction and not manufacture a problem.
Dated means dated. The UI keeps saying what a proposal is not: "A proposal is not proof of today's conditions, an open comment period, or completed construction."

Privacy by default. No accounts, no analytics, no GPS, no route recording, and no persistent storage of reflections: they live in browser memory for the session. The API binds to loopback and rejects cross-origin requests. The only third party is the OpenStreetMap tile server, which sees the map area you're viewing, never your words.

Testing. 32 automated tests cover footprint matching, citation validation, the loopback-only inference boundary, review gates, HTTP behavior, and real React component interactions in JSDOM (including resetting an outing while the model is still thinking). A real-model mode runs the same React flow against local Gemma.

AI assistance, disclosed. I used AI coding assistance and independent source reviews (GPT-6 Astra and Claude Opus 5.5) while building, and Claude Code with HyperFrames and FFmpeg to produce the demo video from a scripted capture of the real app. At runtime, the only AI is local Gemma; nothing calls a hosted model.

Why Does Open Innovation Matter?

Because this app asks people to write down how their own street feels to them.

Your words stay on your machine. Where you walk, who you walk with, what made you uncomfortable: with a closed API, every reflection would leave your computer before you'd even decided whether to share it. With open weights, the whole loop (reflection, connection, draft) runs on 127.0.0.1. The demo's narration ran locally too.
Civic tools should be inspectable. If an AI is going to tell you that your experience relates to a city proposal, you should be able to read exactly how it decides. Here the prompt, the claim list, the validators and the model hash are all in the repo. A community group can audit them, change them, or swap the model.
No meter running. There is no per-request bill, so a library, a tenants' association or a classroom could run it without a budget line or an account.
Reproducible behavior. Pinning an exact open model file means the behavior you test is the behavior you ship. A hosted model can change underneath you; this one can't.

I took it outside

Today I went for a real walk through ZIP 10001 in Manhattan, with the app closed. When I got back I wrote what I noticed, in my own words: "i think that there should be more repairs on the sidewalk, i saw cracks when i walking."

Here's how it went:

It said no, honestly. Sidewalk Senate has one reviewed source so far (Court Square, Queens). For 10001 it answered "No reviewed match. Your thought still belongs here." It didn't borrow the Queens project, and it didn't call the model at all, because only confirmed, reviewed locations go to Gemma.
My words stayed mine. The reflection and the suggestion went into an unsent draft exactly as I typed them.
It found a bug, which I fixed the same day. On a no-match stop, the suggestion panel still said "Edit the AI suggestion... You don't have to agree with the proposal," when there was neither. It now says there's no reviewed proposal for this place and asks for your own suggestion or question (commit).
The real gap is coverage. What I actually wanted to know, which public record or plan covers sidewalk repairs here, is exactly what the app can't answer yet. That's the next step: more reviewed sources and a verified place to send a letter.

What's honest to say about it

One curated source so far. Coverage is one Court Square project with three reviewed intersections. Live search and other cities are future work.
No recipient is verified. The draft says it's unsent and asks who the right recipient is. The app never sends anything.
The model is still a model. Validation guarantees citations point at reviewed claims; it can't guarantee every paraphrase is right. In testing, a reflection where the resident forgot the exact location still got too confident a connection, and positive feedback sometimes got a weak, location-only link. That's why every AI line sits next to your original words and needs your review.
One real outing so far. It's described above. It's one person's walk, not a survey.

Prize Categories

Best Use of Gemma: Gemma 4 E4B runs locally through Ollama and is central to the core workflow: connecting a resident's reflection to dated, page-cited public proposals under deterministic validation.

RoomTidy: a local Gemma reminder built for my roommate

Dennys A — Mon, 05 Oct 2026 03:50:09 +0000

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

What I Built

I built RoomTidy for my roommate: a small Windows desktop application that offers a gentle reminder when visible clutter remains in an area they choose.

The user selects a fixed-camera area, explicitly saves a tidy reference, and sets preferences such as allowing books while asking for dishes to be removed. RoomTidy compares later pictures with that reference locally. It describes visible items; it does not claim to detect dust, prove someone has not cleaned, or judge the person.

The user controls monitoring, snooze, resets and reference updates. References and observation history stay on the computer. The app does not automatically treat persistent clutter as the new tidy baseline. This is a local MVP built for my roommate; recipient feedback and a full timed room trial are still pending.

Demo

Watch the 60-second RoomTidy demo on YouTube

The demo uses generated photographs of a fictional desk, not images of our private room. It runs seven manually staged checks through the actual local comparison and persistence pipeline:

Save and check an explicit tidy reference.
Introduce visible cups, dishes and loose papers.
Show a dark/blocked view; the count remains unchanged.
Observe clutter again.
Reach three valid clutter observations and activate a reminder.
Observe more clutter without repeating the same episode's notification.
Return to the reference and reset the count.

The accelerated demo threshold is three valid observations. It is not a recording of thirty elapsed minutes or thirty hourly checks. Normal monitoring checks hourly while the app and computer are awake, with a default threshold of thirty valid clutter observations.

Code

RoomTidy source code on GitHub

The application source is MIT-licensed. The README explains setup on the tested Windows computer, local storage, model/runtime provenance and known limits. This MVP is not yet a distributable installer for other computers.

How I Built It

RoomTidy uses Python and PySide6 for the desktop interface, OpenCV for camera handling and image checks, SQLite for observation history, and Google Gemma 4 E4B Instruct for understanding changed scenes.

The quantized Q4_0 model and matching BF16 vision projector run through an application-owned llama.cpp process on authenticated loopback. Both artifacts were pinned and SHA256-verified. Google and the official GGUF conversion declare Apache-2.0 licensing.

Gemma receives the user-approved reference and current selected-area picture with allowed-object preferences. It returns a structured status: tidy, clutter_present or unable_to_assess, with a short description of visible evidence. The app validates that response before counting it.

OpenCV rejects dark, overexposed and low-detail images first. Exact readable pixel matches return a factual reference match without asking the model to invent differences. Changed valid scenes use Gemma. Application logic, rather than the model, owns timestamps, counters and reminder deduplication. Unknown and missed checks do not count as clutter evidence.

I used AI coding assistance and Opus/Astra source reviews. The generated demonstration assets came from OpenAI image generation; they were not generated by Gemma. Runtime room-image analysis stays local, with no cloud image uploads or fallback AI API.

Testing mattered more than choosing a model by name. The smaller Gemma E2B candidate failed comparison checks. Initial E4B tests also exposed preference mistakes and false added-object claims on identical pictures. Those findings led to clearer preference instructions and the exact-image safeguard.

The final regression suite passed 71 tests. The seven-step controlled demo produced counters 0, 1, 1, 2, 3, 4, 0. Additional local model checks recognized a dim tidy scene, dim clutter, and a scene whose added objects were explicitly permitted.

These tests do not establish general room accuracy. Camera capture/release was tested separately; classification across genuinely changed real-camera scenes, a full timed monitoring trial, and independently observed Windows toast delivery remain unverified. Windows can suppress toasts, so an active reminder also remains visible in the application.

Why Does Open Innovation Matter?

A room camera captures a private space. Running openly licensed model weights locally lets the app compare pictures without sending them to an image-analysis provider. The user keeps the references, settings and history on their own computer and can pause or delete the app's data.

The open runtime also made model evaluation possible: I could try different weights, inspect failure behavior, and strengthen validation without rebuilding the product around a hosted API. There is no per-request AI-provider billing for local analysis, though hardware, storage and electricity still have costs.

Prize Categories

Best Use of Gemma. Gemma performs the application's central image-understanding task: comparing changed selected-area scenes with an explicit tidy reference while interpreting permitted objects. It is part of the working product, rather than a tool used only to produce the presentation.