DEV Community: Saifuddin Malek

FileSense: Let Local AI Handle the File Names You Keep Putting Off

Saifuddin Malek — Sun, 25 Oct 2026 00:18:18 +0000

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

What I Built

My downloads folder has plenty of files with names like document.pdf, notes_final.txt, and untitled_export.pdf.

Giving them useful names means opening each file, reading it, switching back to the file manager, and typing a name. It’s a small chore that becomes annoying when there’s a whole batch.

I built FileSense to handle the reading and suggest the names.

Upload text-based PDFs or TXT files, generate descriptive filenames, review or edit the suggestions, and download renamed copies together as a ZIP. The original files remain unchanged.

Each suggestion includes a short explanation, and you can inspect the extracted text before accepting it.

Demo

The demo shows document upload, local AI naming, review, and ZIP export.

Code

SaifuddinM23 / RenameAI

FileSense - Privacy-first, local AI-assisted document renaming application with React, Node.js, and Ollama

FileSense - Local AI Document Renamer

FileSense is a privacy-first, local-assisted document renaming application built with React + Vite, Node.js + Express, and local Ollama inference. All uploaded files and extracted text are maintained exclusively inside browser memory—no cloud storage, no account requirements, zero file bytes sent to the backend, and zero modifications to files on your disk.

1. Problem & Workflow

The Problem

Professionals, researchers, and students frequently accumulate folders of documents with obscure or auto-generated filenames such as scan_unread_00492.txt, doc_2026_final_v1.pdf, or untitled_export_draft.pdf. Renaming these files manually requires opening each file, reading its contents to understand the subject, formulating a consistent naming scheme, switching back to the file manager, and typing a new name. Cloud-based AI renaming tools expose confidential documents, contracts, and personal records to third-party servers.

The FileSense Workflow

Upload (Browser Memory Only): Drag and drop or browse PDFs and…

View on GitHub

View the repository and setup instructions

How I Built It

FileSense uses React and Vite for the frontend, Node.js and Express for the backend, and Gemma 3 4B running through Ollama for filename suggestions.

PDF.js extracts text in the browser from up to the first ten pages. A bounded excerpt goes to the local backend and Ollama, which returns a suggested base name and explanation. Zod validates the response before it appears in the review table.

The model interprets the document. Application code handles filename sanitization, duplicate names, and extension preservation.

After review, JSZip packages the selected documents using their original bytes. FileSense creates renamed copies rather than changing files on disk.

Why Does Open Innovation Matter?

Local processing is central to this project. Document excerpts go to a model running on the same machine instead of a third-party cloud AI API. Raw document files stay in browser memory.

There are no per-request cloud inference fees. Local inference still uses hardware, memory, and electricity, but another batch of files does not create another paid API request.

The model is replaceable. Ollama’s configurable model setting lets me experiment with other open-weight models and adapt the naming instructions without rebuilding the workflow around another provider.

A hosted API could also suggest filenames. Using open-weight AI gives me control over where the text is processed and which model performs the task.

The Lazy Payoff

FileSense turns repeated opening, reading, and renaming into one batch review.

The user still checks the suggestions, but starts with proposed names rather than a blank rename field. That is the effort I wanted to remove for this theme.

I have not established a reliable time-saving figure yet. Inference speed depends on the machine, and reviewing suggestions takes time too. The intended benefit is less manual reading and typing.

Limitations and Next Steps

This version supports text-based PDFs and TXT files. Scanned PDFs need OCR, and PDF naming uses only the first ten pages. Suggestions can miss context, so review remains part of the workflow.

Next, I want to compare manual renaming with FileSense on a wider range of documents, including the time spent reviewing and correcting suggestions.

For “Slow and Steady,” I wanted to automate a chore I would otherwise keep postponing: figuring out what document_final_2.pdf actually contains.

PrintBrief: A Local AI Assistant That Turns Messy Messages into Print Orders

Saifuddin Malek — Sat, 17 Oct 2026 21:20:12 +0000

PrintBrief: Turning Messy Customer Messages into Print-Ready Orders with Local AI

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

What I Built

“Bhaiya, 25 copies nikal do, A4, kal chahiye.”

For a print-shop owner, that message leaves several questions: colour or black and white? Single-sided or double-sided? Any binding? What time tomorrow?

I built PrintBrief, a local AI assistant that turns informal customer messages into structured, editable print orders.

It extracts printing instructions, flags missing or contradictory details, and suggests clarification questions. The owner reviews the order, adds a PDF for page counting, and gets an itemized quote based on their shop’s rates.

Once confirmed, the order is saved locally with a quotation snapshot and a downloadable PDF job slip.

Who might pay for it? Small neighbourhood and campus print shops that regularly receive orders through messages. The proposed value is less manual order entry, clearer instructions, and fewer mistakes caused by guessing. That willingness to pay still needs validation with shop owners.

Demo

The demo shows customer-message extraction, missing-information prompts, manual corrections, quotation calculation, order confirmation, and job-slip download.

Code

SaifuddinM23 / printbrief

Local AI Print Shop Order Assistant with in-browser PDF counting, deterministic integer-paise pricing, and job slip generation

PrintBrief — Local AI Print Shop Order Assistant

PrintBrief is a local-first web application designed for neighbourhood and campus print shops. It bridges the gap between chaotic customer WhatsApp/email messages (in English, Hinglish, or shorthand) and precise print production specifications—extracting requirements with a local open-weight LLM, counting PDF pages purely in the browser, calculating deterministic quotes in integer paise, and generating official printable job slips.

1. The Customer Problem

Print shop owners face frequent friction when receiving customer orders:

Chaotic Messages: Customers send ambiguous text messages like "Bhaiya 10 copy nikal do kal 10 baje" without specifying single vs double-sided, colour vs B&W, paper size, binding, or AM vs PM.
Costly Printing Mistakes: Guessing missing specifications leads to wasted paper, mismatched bindings, and disputed bills.
Per-Request Cloud Fees & Data Exposure: Sending customer text to third-party cloud AI APIs introduces per-request inference fees that accumulate across hundreds…

View on GitHub

Repository: PrintBrief on GitHub

How I Built It

PrintBrief uses:

React and Vite for the interface.
Node.js and Express for the local backend.
Gemma 3 4B through Ollama for local order extraction.
Zod to validate and normalize model output.
pdf-lib for browser-based PDF page counting and job-slip generation.
IndexedDB for local order history and saved quotation snapshots.

The open-weight model performs the central task: interpreting informal customer language and converting it into structured order fields.

Application rules then check for issues such as contradictory printing instructions or pickup times without AM/PM. The owner can correct every extracted field before confirming.

Pricing is calculated in code using integer paise. For example, an 11-page document printed double-sided in three separate sets requires 18 physical sheets and 33 printed sides. Binding is charged per set, using the shop’s configured rates.

The project includes deterministic tests for validation, ambiguity handling, and quotation calculations, plus a conditional live Ollama integration check. These checks do not guarantee extraction accuracy on every possible customer message.

Why Does Open Innovation Matter?

Local inference makes the product practical in three ways.

Customer text stays local. With Ollama running on the same computer, the extraction workflow does not need to send customer messages to a third-party AI service. Uploaded PDFs are counted in the browser and are not sent to the model.

There are no per-request cloud inference fees. Running the model locally still uses hardware and electricity, but processing another order does not create another paid API request. That gives a small business a different operating-cost model.

The model can be changed. The Ollama model is configurable, so I can experiment with other open-weight models and improve prompts for the language and shorthand used by a particular shop.

A closed API could also extract order details. The benefit of this approach is control over where inference happens, which model runs, and how the workflow behaves.

Current Status and Next Steps

PrintBrief is a working prototype demonstrated with sample orders. It has not yet been tested by a print-shop owner, and I have not validated pricing or willingness to pay.

My next step is to test it with a local shop, measure the corrections each order needs, and learn whether it saves enough time to become part of their daily workflow.

The goal is simple: help a shop owner turn an unclear message into an order they can confidently print.

GardenFix: Local AI Plant Care That Gets You Off the Screen

Saifuddin Malek — Sat, 10 Oct 2026 01:45:57 +0000

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

What I Built

GardenFix is a local AI plant-care assistant built around a simple idea: take a photo, get one useful check, and return to your plant.

It is for beginners who notice drooping or discoloured leaves but don’t know what to investigate next.

Users upload a plant photo and answer two questions:

When did you last water it?
How much sunlight does it receive?

GardenFix then provides visible observations, possible explanations, and one practical physical check. It also explains what cannot be determined from the photo.

The screen is the starting point. The useful part happens afterward, when someone inspects the soil, drainage, or surrounding conditions themselves. Suggestions are not confirmed diagnoses.

Demo

GardenFix runs locally. You can try it using the setup instructions in the repository below.

Code

SaifuddinM23 / gardenfix

🌱 GardenFix

A local AI plant-care assistant built for the Touch Grass open-source AI challenge.
Everything runs on your own machine — no paid APIs, no cloud dependencies, no authentication. Designed for local processing; works offline after dependencies and model files are downloaded.

Upload a photo of your plant, tell GardenFix when you last watered it and how much sunlight it gets, and receive:

Plant Condition – assessment of overall visual health (Healthy & Thriving, Mild Stress, Severe Distress / Dying)
Visible Observations – AI observations that may contain errors
Possible Explanations – tentative causes tailored to your watering history and sunlight
One Practical Outdoor Check – a physical check with conditional follow-up actions based on what you find
Limitations Notice – clear transparency about what cannot be determined from a photo alone

Tech Stack

Layer	Technology
Frontend	React 18 + Vite 5 (system fonts, Vanilla CSS)
Backend	Node.js +

…

View on GitHub

Source code and setup instructions

The application code is MIT-licensed. Gemma’s model weights are governed separately by its model terms.

How I Built It

The frontend uses React, Vite, and plain CSS. The backend uses Node.js and Express, with Multer for in-memory uploads and Sharp for image processing.

At its core is Gemma 3 4B, an open-weight vision-language model running locally through Ollama.

The backend validates and resizes the uploaded image, then sends it to Gemma alongside the user’s watering and sunlight answers. It requests structured output and validates that response before displaying it.

Gemma performs the image analysis and connects visible features with the supplied care context. The application handles missing model files, unavailable Ollama, and inference errors.

What I Learned From Testing

I tested images showing green foliage and another plant with brown leaves and pronounced drooping. The responses reflected those differences, but they also revealed mistakes.

For example, one response described leaves as detached when the photo did not clearly establish that. Some explanations were also more confident than the evidence justified.

This reinforced an important design decision: observations, possible explanations, and limitations should appear separately. A fluent AI answer still needs human checking. Broader testing and more careful recommendations remain areas for improvement.

Why Does Open Innovation Matter?

GardenFix’s local approach gives me control over where inference happens and how the model is used.

After downloading the dependencies and model files, the app is designed to run without a cloud AI service. In the default local configuration, plant photos and care information are processed on my machine.

There are no per-request AI API charges, although inference still uses local computing resources.

Using an open-weight model also lets me experiment with prompts, adjust the output structure, and explore other compatible models. When testing reveals misleading responses, I can inspect and change the application’s inference instructions.

A closed cloud API could analyse plant images too. The benefit here is being able to build around local processing and offline availability after setup, without depending on a remote AI provider.

For GardenFix, open innovation makes the AI a component I can run and adapt myself.

Prize Categories

Best Use of Gemma

GardenFix uses gemma3:4b through Ollama as its core image-analysis model. It processes plant photos alongside watering and sunlight context to generate observations, possible explanations, and a practical next check.