DEV Community: Nadun Jayaweera

LazyDesk AI: Let Local AI Clean Up Your Digital Mess

Nadun Jayaweera — Thu, 22 Oct 2026 18:39:30 +0000

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

What I Built

I built LazyDesk AI, a local AI-powered file cleanup assistant that helps organize messy filenames without making the user do all the boring decision-making.

The idea is simple:

Your files are messy. Your weekend doesn't have to be.

A lot of us have folders like:

Downloads
Desktop
Documents

filled with files such as:

invoice-final2.pdf
project-final-final-v3.docx
IMG_9988.jpg
meeting_notes_latest.txt
expense-receipt-copy.pdf

Cleaning this manually means deciding:

what each file probably is
what a better filename would be
which folder it belongs in
whether the filename is already good enough
whether two similarly named files are actually related

That is exactly the kind of small task people keep putting off.

LazyDesk AI reduces that effort.

The user simply pastes a list of filenames and clicks:

Organize with AI

The app then uses a local Gemma model to generate a cleanup plan containing:

original filename
suggested filename
suggested folder
reason for the suggestion
confidence level

For example:

invoice-ioc-oct.pdf

might become:

Ioc-October-Invoice.pdf

with a suggested folder:

Finance/Invoices

and an explanation such as:

The filename appears to describe an invoice for Ioc.

Who gets to be a little lazier?

LazyDesk is useful for anyone who regularly deals with messy digital folders, including:

developers
project managers
freelancers
office staff
students
small business owners
anyone whose Downloads folder has become a graveyard

Instead of manually organizing everything one file at a time, the user lets AI make the first set of decisions.

Demo

Here is my video demo:

https://youtu.be/Edtroqk8eAY

The demo shows the full workflow:

Paste messy filenames
        ↓
Enable Lazy Mode
        ↓
Organize with AI
        ↓
Review filename suggestions
        ↓
Review folder suggestions
        ↓
Edit suggestions if needed
        ↓
Approve cleanup plan
        ↓
Save cleanup history locally

One important design choice is that LazyDesk does not automatically rename, move, or delete real files in the current version.

It creates a cleanup plan first.

That keeps the experience safe while still removing most of the decision-making.

Code

The full source code is available here:

https://github.com/nadunjayaweera/lazydesk-ai.git

The project contains:

React frontend
Node.js / Express backend
Ollama integration
Gemma 3 1B local inference
Local JSON persistence

How I Built It

LazyDesk AI uses a simple architecture:

React Frontend
      ↓
Node.js / Express
      ↓
Ollama
      ↓
Gemma 3 1B
      ↓
Structured Cleanup Plan
      ↓
User Review / Edit
      ↓
Approve
      ↓
Local JSON Storage

Frontend

The frontend is built with:

React
Vite
CSS

The main screen contains:

Workspace name
Lazy Mode toggle
Filename input
AI-generated cleanup plan
Editable filename suggestions
Editable folder suggestions
Confidence indicators
Approval button
Cleanup history

The goal was to make the interface feel like a small productivity utility rather than a chatbot.

Lazy Mode

Lazy Mode is the main feature that matches the theme of the challenge.

When it is enabled, the user does not need to manually configure categories or folder rules first.

The concept is:

You provide the mess. AI makes the decisions.

The user pastes something like:

invoice-ioc-oct.pdf
IMG_1234.jpg
Apex-agreement-final.docx
meeting_notes.txt
expense-receipt.pdf
project-final-final-v2.docx

and LazyDesk decides how the files could be organized.

Local AI

LazyDesk currently uses:

Gemma 3 1B

running locally through:

Ollama

The backend sends Gemma the list of filenames with instructions such as:

- Do not delete any file.
- Do not invent file contents.
- Preserve file extensions.
- Suggest clearer filenames.
- Suggest practical folder paths.
- Preserve client or project names.
- Avoid overly long filenames.
- Return valid JSON only.

Gemma returns structured JSON.

Example:

{
  "summary": "Organized 4 files into practical folders.",
  "files": [
    {
      "original_name": "invoice-ioc-oct.pdf",
      "suggested_name": "Ioc-October-Invoice.pdf",
      "folder": "Finance/Invoices",
      "reason": "The filename appears to describe an invoice for Ioc.",
      "confidence": "high"
    }
  ]
}

The response is normalized by the backend before being displayed in React.

Confidence Levels

Each AI suggestion also includes a confidence value:

high
medium
low

This helps the user understand when the model is reasonably confident about a filename versus when the suggestion may need more review.

For example:

invoice-ioc-oct.pdf

may have:

high confidence

while:

IMG_9988.jpg

may have:

low confidence

because the filename itself does not explain what the image contains.

That is important because LazyDesk currently works from filenames only.

It does not pretend to know what is inside a file.

Editable AI Suggestions

I also wanted to avoid treating every AI suggestion as automatically correct.

The user can edit:

suggested filename
suggested folder

before approving the plan.

For example:

AI suggestion:
Projects/Reports

can be changed to:

Clients/Apex/Reports

before approval.

When the cleanup plan is approved, the edited version is saved locally.

This gives the AI the boring first-pass work while keeping the user in control.

Safe by Design

The current version intentionally does not perform destructive actions.

LazyDesk does not automatically:

delete files
rename real files
move real files
inspect file contents

The current workflow is:

Recommend
   ↓
Review
   ↓
Edit
   ↓
Approve

A future version could continue with:

Execute
   ↓
Undo

but I wanted the Hacktoberfest version to focus on safe AI-assisted planning first.

Local JSON Storage

Cleanup plans are stored locally in JSON.

The backend saves them in:

server/data/cleanup-plans.json

Each saved plan contains:

Workspace
Mode
Summary
Status
Files
Created date
Approved date

Because of this, the user can refresh the frontend and still reopen previous cleanup plans.

No database is required for the current MVP.

Why Does Open Innovation Matter?

Open innovation matters a lot for LazyDesk because file organization often involves private or work-related information.

Even filenames can reveal information such as:

salary-report-october.xlsx
client-contract-final.docx
internal-meeting-notes.txt
customer-invoice.pdf

For this kind of utility, I wanted the core AI inference to run locally.

Privacy

Gemma runs locally through Ollama.

That means the filename list does not need to be sent to a third-party cloud AI service for the core cleanup workflow.

This is particularly useful for:

client documents
financial files
internal work files
personal documents
company project folders

No Per-Request AI Cost

File organization is something a person might use repeatedly.

Today it might be:

Downloads

Tomorrow:

Desktop

Next week:

Old Projects

With a paid cloud AI API, each cleanup request can create additional usage cost.

With a local open-weight model, once the model is installed, there is no per-request AI provider charge for the core inference.

That makes LazyDesk practical as a small utility someone can run whenever the digital clutter gets out of control.

Offline-Friendly

Once Ollama and Gemma are installed, the AI inference can run locally without requiring a cloud AI service.

That means LazyDesk can still generate cleanup plans even without an internet connection.

Model Flexibility

LazyDesk is also not permanently tied to one commercial AI provider.

Because it uses Ollama, another compatible open-weight model could be tested later.

For example, different models could be compared for:

filename understanding
folder categorization
inference speed
memory usage
larger context windows
better structured output

That flexibility is one of the main reasons open-weight AI works well for a small utility like this.

The Lazy Payoff

The theme for this challenge is Slow and Steady, and LazyDesk is intentionally designed around doing less manual work.

Without LazyDesk, organizing a messy folder usually looks like this:

Open folder
↓
Look at first file
↓
Decide what it is
↓
Think of a better name
↓
Choose a folder
↓
Repeat for every file
↓
Get bored
↓
Close the folder

With LazyDesk:

Paste filenames
↓
Click Organize with AI
↓
Review
↓
Approve

The AI handles the repetitive first-pass decisions.

The user only spends time correcting suggestions that actually need attention.

That is the lazy payoff:

less deciding, less renaming, less folder planning.

For a small batch of files, the time saved may only be a few minutes.

But for a large Downloads folder or project archive, removing the repeated decision-making can save much more effort.

More importantly, it lowers the mental barrier to starting the cleanup at all.

Sometimes the biggest productivity improvement is simply making an annoying task easy enough that you finally do it.

What I Learned

Building LazyDesk helped me explore AI as a tool for reducing repetitive decision-making rather than just generating text.

I practiced:

running Gemma locally with Ollama
connecting React to local AI
building structured prompts
validating JSON output
building confidence indicators
creating editable AI recommendations
building an approval workflow
persisting data using JSON
designing safer AI automation
keeping the user in control

One of the biggest lessons from this project was that useful automation does not need to be fully autonomous.

For something involving files, it can be better to let AI prepare the work while the human makes the final decision.

That is the balance I tried to build into LazyDesk.

Final Thoughts

LazyDesk AI is intentionally simple.

It does not try to become a complete file management system.

It focuses on one annoying problem:

deciding how messy files should be organized.

The user provides the filenames.

Gemma provides the first-pass cleanup plan.

The user reviews it.

Then LazyDesk remembers the decision.

For the Slow and Steady challenge, that felt like the right approach:

Let AI do the boring part so you can be a little lazier.

MenuBridge AI: Local AI Menu Translation That Preserves the Identity of Local Dishes

Nadun Jayaweera — Sat, 17 Oct 2026 17:16:46 +0000

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

What I Built

I built MenuBridge AI, a local AI-powered restaurant menu translation assistant.

The idea came from a practical problem in the hospitality industry.

Restaurants, cafés, hotels, villas, and other hospitality businesses often serve international guests and need multilingual menus. Translating normal text is relatively straightforward, but restaurant menus are different.

Local dishes such as:

Kottu
Pol Sambol
Hoppers
Lamprais
Watalappan

have cultural meaning that can easily be lost when they are translated literally.

For example, a restaurant probably does not want Kottu converted into an awkward literal translation.

Instead, it may want something like:

Seafood Kottu
→
Kottu aux fruits de mer

while translating the description naturally for French-speaking customers.

That is what MenuBridge AI is designed to do.

It allows the restaurant to enter:

Restaurant name
Source language
Target language
Dish name
Description
Category

The restaurant can also maintain its own Restaurant Dictionary.

For example:

Term:
Kottu

Rule:
Keep the word Kottu in the translated menu name.

Another example:

Term:
Pol Sambol

Rule:
Keep Pol Sambol as the original dish name and describe it as a Sri Lankan coconut relish.

These rules are automatically included when the local AI model generates the translation.

Who would pay for it?

The target users are:

Restaurants
Cafés
Hotels
Villas
Guest houses
Food delivery businesses
Tourism businesses

A small hospitality business may regularly need menu translations but may not have an in-house translator.

MenuBridge AI could therefore work as either:

a one-time menu translation service, or
a low-cost recurring menu translation tool.

The important part is that the restaurant can define how its own dishes should be handled instead of relying completely on a generic translator.

Demo

Here is my video demonstration of MenuBridge AI:

https://youtu.be/TvbMEBuHEhk

The demo shows the complete workflow:

Restaurant Setup
        ↓
Add Menu Item
        ↓
Restaurant Dictionary
        ↓
Translate with Local AI
        ↓
Review Translation
        ↓
Approve
        ↓
Translation History
        ↓
Export Approved Menu

The application also keeps generated translations and terminology rules locally so they remain available after refreshing the application.

Code

The complete source code is available on GitHub:

https://github.com/nadunjayaweera/OrderInRestaurant-ai.git

The project contains both the React frontend and Node.js/Express backend.

How I Built It

MenuBridge AI uses a relatively simple architecture:

React Frontend
      ↓
Node.js / Express
      ↓
Restaurant Dictionary
      ↓
Ollama
      ↓
Gemma 3 1B
      ↓
Structured JSON Translation
      ↓
Review / Approve
      ↓
Local JSON Storage
      ↓
CSV Export

Frontend

The frontend is built with:

React
Vite
CSS

The interface contains three main areas.

1. Restaurant Setup

The user selects:

Restaurant Name
Source Language
Target Language

For example:

Restaurant: Ceylon Kitchen
Source: English
Target: French

2. Menu Item

The restaurant enters the existing menu item.

For example:

Dish:
Seafood Kottu

Description:
Chopped roti mixed with prawns, cuttlefish,
vegetables, egg, spring onions, and house spices.

Category:
Main Course

3. Restaurant Dictionary

This is one of the most important parts of the project.

Instead of asking a generic translation model to decide everything itself, the restaurant can provide terminology instructions.

For example:

Kottu
Keep the word Kottu in the translated menu name.

or:

Hoppers
Keep the original word Hoppers and explain that it
is a Sri Lankan bowl-shaped pancake.

These instructions are stored locally and sent to the AI when a menu item is translated.

Local AI

MenuBridge AI currently uses:

Gemma 3 1B

running locally through:

Ollama

The backend sends Gemma information about:

the restaurant
source language
target language
menu item
description
category
restaurant terminology rules

I also instruct the model to follow several important rules:

- Preserve culturally important dish names.
- Follow the restaurant terminology rules.
- Never invent ingredients.
- Never remove ingredients.
- Do not change allergen or dietary information.
- Avoid awkward literal translations.
- Keep descriptions concise.
- Return valid JSON only.

Gemma then returns a structured result such as:

{
  "original_name": "Seafood Kottu",
  "translated_name": "Kottu aux fruits de mer",
  "translated_description": "Roti haché sauté avec des crevettes, de la seiche, des légumes, un œuf et des épices maison.",
  "cultural_note": "Kottu is a Sri Lankan dish name and has been preserved.",
  "kept_original_term": true
}

Using JSON output makes it much easier for the frontend to reliably display the generated translation.

Translation Review and Approval

I did not want the application to treat every AI-generated translation as automatically correct.

Every generated result is initially stored as:

GENERATED

The restaurant can review it and then approve it.

After approval:

APPROVED

is stored with the translation.

This gives the restaurant control over what eventually gets published.

That matters because even a good AI translation can sometimes choose terminology differently from what the business prefers.

Local JSON Storage

I intentionally kept the project lightweight.

Instead of adding MySQL or another database, MenuBridge stores its current data in local JSON files.

It stores:

Restaurant terminology rules
Generated translations
Approved translations

This means that refreshing the React application does not remove the restaurant's terminology or translation history.

It also keeps the MVP simple enough for a small business use case.

CSV Export

Approved menu translations can be exported as CSV.

The export includes information such as:

Restaurant
Category
Source Language
Target Language
Original Name
Original Description
Translated Name
Translated Description
Cultural Note

This makes the translated data easier to move into other workflows such as:

Excel
Google Sheets
restaurant POS systems
online menus
QR menus
printed menus

Testing with Sri Lankan Dishes

I tested MenuBridge with several Sri Lankan dishes because they are good examples of why restaurant translation needs context.

Some of the test items included:

Seafood Kottu
Pol Sambol
Egg Hoppers
String Hoppers
Lamprais
Isso Wade
Watalappan

For culturally important terms, I used restaurant dictionary rules to tell the AI when the original name should remain.

For example:

Lamprais

can remain Lamprais, while the menu description explains what it is to an international customer.

That is more useful than replacing the culturally recognized name with an overly literal translation.

Why Does Open Innovation Matter?

Open innovation is particularly important for MenuBridge AI because this is intended to be useful for small businesses.

Lower Operating Cost

A restaurant may translate hundreds of menu items over time.

It may also repeatedly update:

seasonal dishes
descriptions
ingredients
menu categories
promotional menus

If every translation requires a paid cloud AI request, the operational cost grows with usage.

With MenuBridge AI, Gemma runs locally through Ollama.

Once the model is installed, the application does not need to pay an AI provider for every translation request.

That makes a low-cost side-hustle product much more realistic.

Privacy

Restaurants may also have menu information they would prefer to keep internally.

That could include:

upcoming dishes
recipe descriptions
ingredient information
internal terminology
restaurant-specific naming conventions

Running the model locally means the core AI translation can happen on the restaurant's own machine rather than requiring the menu data to be sent to a remote AI service.

Restaurant-Specific Customization

This is probably the biggest advantage for this project.

A generic translator does not know how every restaurant wants its dishes represented.

MenuBridge allows a business to define instructions such as:

Kottu
→ Keep Kottu in the name

Pol Sambol
→ Keep the original term and explain that it is
a Sri Lankan coconut relish

Hoppers
→ Keep Hoppers and explain the type of dish

The open-weight AI model can then use these instructions as context.

This gives the restaurant more control over how its menu is translated.

Model Flexibility

The application is also not permanently tied to one commercial AI provider.

Because the inference layer runs through Ollama, I can experiment with other compatible open-weight models later.

That means MenuBridge could eventually evaluate different models for:

translation quality
language support
speed
hardware requirements
restaurant terminology handling

without redesigning the entire product around one proprietary API.

Could This Become a Real Side Hustle?

Yes.

The project is intentionally small and focused on one business problem.

A possible service could be:

Restaurant provides their existing menu
        ↓
MenuBridge translates it
        ↓
Restaurant reviews translations
        ↓
Approved multilingual menu is exported

It could be offered as:

One-Time Menu Translation

for a restaurant that only needs an existing menu translated.

Or it could later become:

Monthly Menu Translation Service

for restaurants that regularly add or change dishes.

Future commercial features could include:

Bulk Excel upload
Multiple target languages at once
Restaurant accounts
Multiple restaurant profiles
Translation editing
QR menu generation
POS integration
Menu publishing
Translation history
AI-assisted allergen checks

For this challenge, however, I intentionally kept the MVP focused on the central problem.

What I Learned

This was another step in my journey of learning how open-weight AI can be integrated into real applications.

I practiced:

Running Gemma locally with Ollama
Connecting local AI to Node.js
Building structured prompts
Requesting predictable JSON output
Validating model-generated data
Connecting React to an AI backend
Persisting application data with JSON
Building review and approval workflows
Exporting generated content to CSV
Designing AI around a specific industry problem

One of my biggest takeaways from this project is that the model itself does not need to solve everything.

Giving the restaurant control through terminology rules makes the overall system much more useful.

The AI provides flexibility, while the restaurant provides domain knowledge.

That combination is what makes MenuBridge different from simply putting a generic translation box inside an application.

Final Thoughts

The goal of MenuBridge AI is simple:

Translate the menu, not the identity of the food.

A restaurant should be able to make its menu understandable to international customers while still keeping the names and cultural meaning that make its dishes unique.

Using Gemma locally through Ollama made it possible to build this without requiring a paid AI API or sending every menu item to an external AI provider.

For a small hospitality business, that combination of:

Local AI
+
Restaurant-specific terminology
+
Human review
+
Simple export

could become a practical and affordable menu translation workflow.

OutsideFlow AI: Spend Less Time Planning and More Time Outside

Nadun Jayaweera — Fri, 09 Oct 2026 19:44:11 +0000

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

OutsideFlow AI: Spend Less Time Planning and More Time Outside

What I Built

I built OutsideFlow AI, a local AI-powered outdoor activity planner designed to do something slightly unusual for an AI application:

get people away from the screen.

A lot of apps are designed to increase engagement and keep users inside the application for as long as possible.

OutsideFlow does the opposite.

The user opens the app, tells it how much free time they have, how they are feeling, and what kind of outdoor environment is available.

For example:

Available time: 30 minutes
Mood: Relax
Environment: Neighborhood

Extra preference:
I want something quiet and I don't want to spend money.

OutsideFlow then uses a locally running open-weight AI model to create a short outdoor plan.

A generated plan might look like this:

30-Minute Neighborhood Reset

1. Walk outside without headphones — 10 min
2. Notice three things you normally ignore — 7 min
3. Sit somewhere quiet and observe your surroundings — 8 min
4. Walk home at a comfortable pace — 5 min

The user then clicks:

Start Outdoor Session

and the app displays one final message:

Put your phone away and go 🌿

That is the main idea behind the project.

The screen should be the shortest part of the experience.

Who is it for?

OutsideFlow is for people who want to spend more time outdoors but sometimes get stuck deciding what to do.

Someone may only have 15 or 30 minutes available.

They may want to relax, exercise, explore, or do something social.

Instead of spending another 20 minutes searching online for ideas, OutsideFlow creates a simple plan in seconds and encourages the user to leave the screen.

Demo

Here is a short video showing OutsideFlow AI in action:

YouTube Demo:

The demo shows:

Selecting available time
Selecting a mood
Choosing an outdoor environment
Adding an optional preference
Generating an outdoor plan with Gemma
Starting the outdoor session
Reaching the final "Put your phone away and go" screen

Code

The complete source code is available on GitHub:

GitHub Repository:

nadunjayaweera / outsideflow-ai

A local AI outdoor activity planner built with React, Node.js, Ollama and Gemma for Hacktoberfest 2026 Touch Grass.

OutsideFlow AI

OutsideFlow AI is a local AI-powered outdoor activity planner built for the Hacktoberfest 2026 Open-Source AI Challenge Week 1: Touch Grass.

The goal is simple:

Spend less time planning. Spend more time outside.

OutsideFlow asks the user for a few preferences, generates a personalized outdoor plan using a locally running open-weight AI model, and then encourages the user to put the phone away and actually go outside.

Challenge Theme

This project was built for the Hacktoberfest 2026 theme:

Touch Grass

The challenge asks participants to build something with open-source AI that gets people off the screen and into the real world.

OutsideFlow is designed specifically around that idea.

The screen is only used for a short planning step.

After the outdoor plan is generated, the user starts the session and is encouraged to:

Put your phone away and go 🌿

The Problem

People often want to take…

View on GitHub

OutsideFlow is a small full-stack application built with:

React
Vite
Node.js
Express
Ollama
Gemma 3 1B

How I Built It

OutsideFlow follows a simple architecture:

User Preferences
       ↓
React Frontend
       ↓
Node.js / Express Backend
       ↓
Ollama
       ↓
Gemma 3 1B
       ↓
Structured Outdoor Plan
       ↓
React Session Screen
       ↓
Put the phone away and go outside

Frontend

The frontend is built with React and Vite.

The user selects:

Available time: 15, 30, or 60 minutes
Mood: Relax, Exercise, Explore, or Social
Environment: Neighborhood, Park, Garden, Beach, or Anywhere
Optional extra preferences

The frontend sends those values to the backend.

Backend

The backend is built with Node.js and Express.

It receives the user's preferences and creates a prompt for the AI model.

For example:

{
  "time": "30",
  "mood": "Relax",
  "environment": "Neighborhood",
  "note": "I want something peaceful and I don't want to spend money."
}

The backend asks Gemma to return structured JSON.

Example:

{
  "title": "30-Minute Quiet Neighborhood Reset",
  "goal": "Relax outside with a calm and simple walking session.",
  "activities": [
    {
      "step": 1,
      "activity": "Walk slowly around your neighborhood without headphones",
      "duration": "10 min"
    },
    {
      "step": 2,
      "activity": "Notice three plants or details you usually ignore",
      "duration": "7 min"
    },
    {
      "step": 3,
      "activity": "Sit somewhere quiet and observe your surroundings",
      "duration": "8 min"
    },
    {
      "step": 4,
      "activity": "Walk home at a comfortable pace",
      "duration": "5 min"
    }
  ]
}

The backend validates and normalizes the response before returning it to React.

AI

OutsideFlow uses:

Gemma 3 1B

running locally through:

Ollama

I chose a small model because this project does not need a huge cloud-based model.

The AI only needs to understand a few user preferences and generate a practical, structured outdoor plan.

Session Mode

One part I specifically added for the challenge theme was the outdoor session screen.

After generating the plan, the user clicks:

Start Outdoor Session

The normal planning UI disappears.

The session screen shows only the essential steps and tells the user:

Your plan is ready. The rest happens outside.

That was important because I did not want to build an outdoor app that still required the user to stare at the screen throughout the whole experience.

Why Does Open Innovation Matter?

Open innovation matters a lot for OutsideFlow because the AI is not simply an optional feature.

It is what makes the personalized planning possible.

A hard-coded application could display a list of generic outdoor ideas.

But it would struggle to adapt naturally to combinations such as:

15 minutes + Exercise + Beach

or:

60 minutes + Explore + Park + no spending

Using an open-weight model makes the application much more flexible.

Local Inference

Gemma runs locally on the user's machine through Ollama.

That means the core AI functionality does not need to send every request to a cloud AI service.

Privacy

A user's preferences can contain personal information.

For example:

I am feeling stressed today.
I only have 20 minutes.
I want somewhere quiet.

With local inference, those preferences can remain on the user's own computer.

No Per-Request AI Cost

OutsideFlow does not need a paid AI API every time someone generates a plan.

Once Gemma is installed locally, the user can generate plans without paying for each request.

Model Flexibility

The application is not permanently tied to one AI provider.

Because the AI layer runs through Ollama, another supported open-weight model could be tested or swapped in later.

Offline-Friendly

Once Ollama and the model are installed, the core planning feature can run locally without depending on an external AI API.

That fits the idea behind OutsideFlow especially well.

An application that encourages people to go outside should not require constant cloud connectivity just to create a simple activity plan.

Touch Grass

The challenge theme made me think differently about how AI applications are usually designed.

Many AI products encourage users to stay inside the interface:

Ask another question
↓
Generate another response
↓
Keep scrolling
↓
Repeat

OutsideFlow intentionally changes that pattern:

Choose preferences
       ↓
Generate plan
       ↓
Start session
       ↓
Put phone away
       ↓
Go outside

The AI is there to remove the planning friction, not become the activity itself.

That is the part of the project I like most.

What I Learned

OutsideFlow was my second Hacktoberfest 2026 project using open-weight AI.

My first challenge project helped me learn how to run Gemma locally and connect it to a React and Node.js application.

For this challenge, I focused more on how AI can shape the actual product experience.

I practiced:

Running Gemma locally through Ollama
Sending structured user preferences to an AI model
Designing prompts that return predictable JSON
Validating AI-generated results in Node.js
Connecting local inference to React
Designing around limited screen interaction
Using AI to encourage a real-world activity instead of more screen time

One thing I found interesting is that AI does not always have to increase digital engagement.

It can also be used to help people leave the screen.

My Agent Session

I did not use a DevRelay agent session for this project.

The application uses a straightforward local AI architecture with Gemma running through Ollama.

Prize Categories

I am entering OutsideFlow AI in:

Best Use of Gemma

Gemma 3 1B is the core AI model responsible for creating the personalized outdoor activity plans.

Final Thoughts

The idea behind OutsideFlow is intentionally simple:

Use the screen just long enough to decide what to do, then go do it.

AI is often used to keep people inside digital experiences.

For this challenge, I wanted to try the opposite.

OutsideFlow uses AI to remove the small amount of planning that can stop someone from taking a break, walking outside, exploring somewhere nearby, or simply getting some fresh air.

The app creates the plan.

The actual experience happens outside. 🌿

FriendFlow AI: Turning Messy Thoughts into Clear Tasks with Local AI

Nadun Jayaweera — Fri, 02 Oct 2026 20:05:43 +0000

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

FriendFlow AI: Turning Messy Thoughts into Clear Tasks with Local AI

What I Built

I built FriendFlow AI, a privacy-first local AI task organizer for my friend Sandaru, who is a software engineer.

Like many developers, Sandaru has a heavy daily workload. He has meetings, development tasks, code reviews, personal errands, reminders, and other responsibilities happening at the same time.

Because of that workload, he sometimes forgets small daily tasks.

The usual solution would be to use a task management application, but I noticed another problem: traditional task managers can actually create more friction for someone who is already busy.

To create a single task, you may need to:

Type the task title
Choose a priority
Select a date
Add details
Save the task
Repeat the same process for every other task

When someone already has many things on their mind, organizing everything manually can become another task by itself.

I wanted to make that process much simpler.

That is where FriendFlow comes in.

Instead of manually creating tasks one by one, Sandaru can simply write or paste everything that is on his mind in one messy paragraph.

For example:

Tomorrow I need to review the API PR, buy milk,
send the project report today, and call Kasun.

FriendFlow sends that unstructured text to a locally running open-weight AI model.

The AI then turns the note into structured tasks such as:

Review the API PR
Tomorrow
High Priority

Buy milk
No date
Medium Priority

Send the project report
Today
High Priority

Call Kasun
No date
Medium Priority

The user can then mark tasks as completed, and finished tasks are moved into a completed-task history.

The goal is simple:

Dump your thoughts first. Organize them later with AI.

Demo

Here is a short video showing FriendFlow in action:

https://youtu.be/4JgI4OzFFLs

The demo shows:

Entering an unstructured note
Sending the note to the local AI model
Automatically generating structured tasks
Detecting priorities and deadlines
Marking a task as completed
Saving completed tasks in local history

Code

The complete project is available on GitHub:

https://github.com/nadunjayaweera/friendflow-ai

FriendFlow is built as a small full-stack application with a React frontend and a Node.js/Express backend.

How I Built It

FriendFlow uses the following stack:

Frontend

React
Vite
CSS

Backend

Node.js
Express

AI

Ollama
Gemma 3 1B

Storage

Local JSON storage

The basic architecture looks like this:

User Note
    ↓
React Frontend
    ↓
Node.js / Express Backend
    ↓
Ollama
    ↓
Gemma 3 1B
    ↓
Structured JSON Tasks
    ↓
React Task List
    ↓
Local JSON Storage

The React frontend sends the user's note to an Express API endpoint.

The backend creates a prompt asking Gemma to extract actionable tasks from the note.

Gemma returns structured task information including:

Task title
Due date
Priority

The backend validates and normalizes the AI response before saving the tasks locally.

The generated tasks are then returned to the frontend and displayed to the user.

When a task is completed, it is removed from the active task list and moved into completed-task history.

One of the interesting parts of this project was making the AI output reliable enough for the frontend.

Instead of allowing the model to return free-form text, I instructed it to return structured JSON.

For example:

{
  "tasks": [
    {
      "title": "Send project report",
      "dueDate": "Today",
      "priority": "High"
    }
  ]
}

The backend also handles different possible response structures and normalizes them before sending the final task data to React.

Why Does Open Innovation Matter?

Open innovation is not just something I added to FriendFlow to meet the challenge requirement.

It directly influenced how I designed the application.

Personal notes can contain a lot of private information.

A user may write about:

Work projects
Client names
Personal plans
Family matters
Deadlines
Private reminders

For FriendFlow, I did not want every personal note to automatically be sent to an external AI provider.

Instead, I used Gemma 3 1B running locally through Ollama.

This means the AI inference can happen directly on the user's machine.

The note does not need to be sent to a third-party AI API.

That gives FriendFlow several advantages.

Privacy

The user's notes can remain on their own machine.

This is especially important for work-related or personal information.

No AI API Cost

There is no per-request cost for organizing tasks.

Once the model is installed locally, FriendFlow can use it without paying for every prompt.

Model Flexibility

The application is not permanently tied to a single AI provider.

Because Ollama supports multiple models, I can experiment with or replace the model later without rebuilding the entire application.

User Control

The user controls both the AI runtime and the task data.

FriendFlow stores task information locally instead of depending on an external cloud database.

Local Inference

The most interesting part for me was seeing that a small open-weight model could perform a useful everyday task directly from my own computer.

Before this challenge, I had very little experience working with AI models.

Building FriendFlow helped me understand that integrating an open-weight model does not always require training a model or having deep machine-learning knowledge.

Sometimes, the most useful approach is simply giving a model a clear responsibility inside an application.

In FriendFlow, that responsibility is turning messy human thoughts into structured tasks.

Building for Sandaru

The theme of this challenge was Build for a Friend, and that changed how I approached the project.

Instead of trying to build a large general-purpose AI application, I focused on one small problem that someone I know actually experiences.

Sandaru does not need another complicated productivity platform.

He needs a faster way to capture what is already in his head.

That is why FriendFlow intentionally keeps the interaction simple:

Sandaru said the most useful part was being able to dump several thoughts at once instead of creating tasks one by one.

Write everything
        ↓
Click Organize with AI
        ↓
Get clear tasks

The project is small, but the problem is real.

That was one of my favorite parts of this challenge.

What I Learned

This was also my first real experience building an application around an open-weight AI model.

I learned how to:

Run Gemma locally using Ollama
Send prompts to a local model from Node.js
Request structured JSON output from an AI model
Validate AI-generated responses
Connect local AI inference to a React application
Persist AI-generated task data locally
Design an application where AI performs a specific useful function

The biggest lesson for me was that I did not need to understand model training before I could start building useful applications with open models.

As a web developer, I could treat the model as another service inside my application and gradually learn how it behaves.

My Agent Session

I did not use an agent session for this submission.

The project was built using a simple local AI architecture with Gemma running through Ollama.

Prize Categories

I am entering FriendFlow in:

Best Use of Gemma

Gemma 3 1B is the core AI model responsible for converting unstructured user notes into structured tasks.

Final Thoughts

Hacktoberfest 2026 pushed me into an area I had not explored much before: open-weight AI.

I started this challenge without much knowledge about AI models.

By the end, I had a working application where a locally running Gemma model was solving a real problem for someone I know.

FriendFlow may be a small project, but that is also what I like about it.

It takes one repetitive part of task management and removes it.

Instead of carefully organizing every thought before saving it, the user can simply write naturally and let the AI handle the structure.

Sometimes the most useful tools are not the biggest ones.

They are the ones that remove a little bit of friction from someone's day.