DEV Community: softGpt 9299

SlothDesk: Stop Scrolling Client Chats. Start With a Clear Work Plan.

softGpt 9299 — Fri, 23 Oct 2026 09:51:46 +0000

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

A client asks you to change a heading. Ten messages later, they cancel that request and ask you to fix the contact form instead. The next morning, you read the entire thread again to figure out what actually needs doing.

I built SlothDesk to prepare that work plan for review.

What I Built

SlothDesk turns client conversations into proposed tasks, decisions, clarification questions and a reply draft. Paste a conversation or upload a text export, inspect the supporting messages, and accept the changes you want on your project board.

The most useful part is handling changed instructions: the final work plan should reflect what the client currently wants. Cancelled requests, revised deadlines and follow-up messages deserve more than another summary.

Demo

Try SlothDesk

Create a project, load a bundled English or Hinglish conversation, and analyse it. Inspect the proposed changes and source messages before accepting selected items. Then import a follow-up to review how the plan changes.

Hosted demo limitation: the deployed app currently reports that Ollama is unavailable and uses its rule-based fallback. This demonstrates the workflow, not an actual open-weight model run. The repository provides the local Ollama integration.

Code

Gautam5514 / hack_week4

🦥 SlothDesk — Skip the chat scroll. Get the work.

SlothDesk turns messy client conversations into an actionable work plan using AI running locally on your computer. Paste a chat (or upload a .txt export) let it analyse, review the proposed changes, and accept the ones you want.

Built for freelancers, agency owners, and project managers who otherwise re-read long client threads to reconstruct tasks, deadlines, and changed instructions by hand.

Works in mixed Hindi/English (Hinglish) and English.

The one workflow it does well

Import chat  →  Review proposed changes  →  Accept  →  Project board
   (paste/upload)   (New/Updated/Cancelled/      (commit     (edit, status,
                     Needs-review + evidence)     selected)    follow-up, export)

The model’s output is never written straight to your board. Every analysis produces a proposal you review and accept — so you stay in control and nothing is invented into your task list.

Its signature trick is reconciliation: when a client says…

View on GitHub

How I Built It

The project uses Next.js, TypeScript and Tailwind. The local inference path calls Ollama with a configurable model, defaulting to Gemma 3 4B. JSON Schema and Zod validate the extraction structure; application logic handles message IDs, date resolution, reconciliation and persistence.

Model output becomes a proposal. It does not automatically become an accepted task. That review step is central to the product.

The local configuration uses SQLite. According to the README, the serverless deployment falls back to ephemeral in-memory storage, so the hosted demo should not be treated as durable project storage.

Why Open Innovation Matters

With the local setup, users can run an open-weight model on hardware they control, inspect the extraction prompt, and replace the model. They do not need to build this workflow around a single proprietary inference provider.

Gemma weights have their own terms; the application code is MIT licensed. Local inference avoids per-request hosted inference fees, while still requiring hardware and electricity.

Privacy claims apply to the local configuration. The hosted website is a server-backed demo: do not upload confidential conversations on the assumption that processing stays in your browser.

Evaluation and Limitations

The README reports 14 passing cases for the deterministic fallback on its small bundled dataset. These are author-reported fallback results, not a model-quality benchmark or evidence of performance on arbitrary client conversations.

Actual local-model performance and time savings still need measured validation. I am not claiming a percentage of time saved.

The current scope is text input, proposed work plans, source evidence and human review. Live WhatsApp/Slack integrations, automatic sending and voice transcription are outside this version.

The Lazy Payoff

The intended payoff is straightforward: stop reconstructing a task list from the same conversation repeatedly. Let the software prepare a reviewable plan, then use your attention on the decisions that still need a person.

AI disclosure: This article and cover were generated with AI tools from my project materials and instructions. Model benchmarks and time savings have not been independently verified.

LedgerZero AI: Turn Receipts into a Reviewable Ledger with Local Gemma

softGpt 9299 — Sat, 17 Oct 2026 17:55:42 +0000

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

What I Built

LedgerZero AI turns a folder of receipts into a ledger a freelancer can actually review. Its open-weight extraction engine runs through Ollama on the user's own machine, with a dashboard for checking records, spotting duplicates, and exporting the result.

A receipt is a tiny document with a surprisingly long afterlife. Someone has to identify the merchant, find the real total, choose a category, check whether it has already been entered, and hand the result to a bookkeeper. Repeat that across software subscriptions, equipment purchases, coworking bills, and client meetings, and a small administrative job becomes a recurring distraction.

LedgerZero brings those steps into one workflow:

Extract the vendor, date, invoice reference, currency, amounts, and line items.
Suggest expense categories with Schedule C references.
Flag duplicate invoice numbers and matching vendor/date/amount combinations.
Surface missing information and unusual transactions for review.
Search, filter, and edit the ledger before exporting CSV or a printable audit pack.

The intended customer is a freelancer or independent contractor who wants help organizing business expenses while keeping control of the documents.

Why someone would pay

The product hypothesis is simple: charge for a convenient, supported desktop experience around an open core.

The repository proposes a free MIT community edition, a $49 one-time Pro desktop license, and a $149 agency edition. Those are proposed packages, not evidence of sales or shipped paid editions. Multi-client workflows and support would need further development and validation.

Local inference makes a one-time purchase more plausible because each additional receipt does not incur a metered cloud-model API charge. Hardware, electricity, maintenance, and support still have costs.

Demo

Open the LedgerZero AI demo

For a quick walkthrough:

Open the dashboard and choose Load Sample Invoices.
Inspect the extracted records and suggested categories.
Open the IRS Schedule C Form view.
Try the CSV export or Audit Pack.

The hosted demo and local installation have different privacy boundaries. The Vercel demo uses server API endpoints and currently reports the heuristic fallback engine. It is a preview of the workflow; it does not run Gemma inside your browser. Use synthetic sample documents there. To keep document processing on your own computer, run both the app server and Ollama locally.

Code

Source code on GitHub — released under the MIT license.

Gautam5514 / hack_week3

⚡ LedgerZero AI

100% Local, Air-Gapped AI Invoice, Receipt & Tax Sorter for Freelancers
Built with open-weight models at its core (Google Gemma 2, Meta Llama 3.2, Qwen 2.5). Client invoices, contracts, and financial receipts never leave your laptop.

📖 Table of Contents

✨ Why LedgerZero AI?

Freelancers, independent software contractors, and boutique agencies handle sensitive financial documents daily: client invoices, subcontractor agreements, cloud hosting bills, and hardware receipts.

Existing tools fail freelancers:

Cloud Accounting SaaS (QuickBooks, Expensify): Charge $20–$35/month recurring subscriptions and leak client billing telemetry to third-party cloud servers.
Cloud AI APIs (ChatGPT,…

View on GitHub

To try the local open-weight path:

git clone https://github.com/Gautam5514/hack_week3.git
cd hack_week3
npm install

# With Ollama installed:
ollama pull gemma2:2b
ollama serve

If Ollama is already running, skip the last command. In another terminal:

npm start
# Open http://localhost:3030

Choose Gemma in the dashboard. The repository also includes Node.js and Python command-line tools.

How I Built It

The stack is deliberately small: Node.js, Express, vanilla JavaScript and CSS, a JSON document store, and Ollama for local inference.

The processing flow is:

Document text
    → structured extraction with Ollama / Gemma
    → field normalization
    → rule-based expense categorization
    → duplicate and anomaly checks
    → editable ledger
    → CSV / summary / printable audit pack

Gemma does the extraction

The default local model is Gemma 2 (gemma2:2b). The extractor checks the local Ollama service, builds a prompt containing the document text and expected fields, then calls /api/generate with JSON output enabled.

The expected structure includes vendor, date, currency, subtotal, tax, total, payment method, client name, and line items. After generation, the code normalizes numeric values, dates, currency codes, and item arrays before passing the document onward.

The connector also supports other installed models, including Llama and Qwen. That is a configurable integration, not a claim that every model has been benchmarked equally.

Rules handle the repeatable work

Category mapping and duplicate checks live outside the model. Keeping those operations explicit makes the result easier to inspect: a user can see the assigned category and review warnings instead of relying on a paragraph of generated financial advice.

If Ollama is unavailable, times out, or returns unusable output, a deterministic parser supplies a fallback. That lets users explore the workflow before downloading a model, while preserving a separate open-weight extraction path for local use.

What still needs work

This is a working prototype with an editable review step, not unattended bookkeeping.

A verification run against the submitted source passed the categorizer tests but found failures in the extraction, multi-currency, and number-formatting suites. Those cases need improvement; I am not claiming production-level accuracy or a fully passing test suite. Image extraction also depends on choosing a suitable vision-capable model, and the bundled PDF parser has limitations.

The tax views are simplified organizational estimates. Suggested categories, deduction percentages, and the dashboard's assumed 25% tax rate need review against the user's actual circumstances; an audit score is an application heuristic, not a certification.

Why Does Open Innovation Matter?

For this product, where inference runs is part of the value.

With downloadable open weights and a local runtime, a freelancer can process documents on a machine they control after the software and model are installed. Document extraction does not require sending the contents to a third-party model API.

That architecture also gives the project room to evolve:

Model choice: use a smaller model for limited hardware or test another model against difficult document formats.
Inspectability: the prompts, normalization code, category rules, and duplicate logic are available in the repository.
Portable deployment: users can run their own copy instead of depending on one hosted application.
Different economics: local processing avoids per-request model API billing, making a supported one-time license worth exploring.

The open pieces are central to the intended product: they make user-controlled inference possible. The heuristic fallback is useful for onboarding, but it does not replace the model's role in extracting varied document text.

Prize Categories

Overall challenge prize
Best Use of Gemma — Gemma 2 is the default model in the local Ollama extraction connector. The hosted demo uses the fallback; judges can follow the local setup above to exercise the Gemma path.

Built by Gautam Pandit. The next milestone is improving extraction reliability and testing the workflow with freelancers before treating the proposed pricing as validated demand.

AI assistance was used to prepare this submission and its cover artwork.

WildQuest AI (Touch Grass): On-Device AI Scavenger Hunts That Get You Outside

softGpt 9299 — Sat, 10 Oct 2026 06:40:47 +0000

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

What I Built

WildQuest AI turns a short walk into a nature-discovery game. Pick a session of 3, 5, or 7 missions (roughly 5-20 minutes), and each mission asks you to find something real outside — a leaf, a flower, bark, the sky. You open your camera, photograph what you found, and an on-device AI model checks whether it's a match. There are no feeds, no streaks, and no accounts — just a short list of reasons to look up from your screen. When the session ends, the app tells you to put the phone away.

It's for anyone who wants a tiny, concrete excuse to step outside: someone on a work break, a parent keeping a kid occupied on a walk, or a remote worker who needs ten real minutes of air between meetings.

Demo

Live app: https://touch-grass-sepia-theta.vercel.app/

It's installable as a PWA — add it to your home screen, and after the first visit (which downloads the ~90MB model) it keeps working offline.

Code

GitHub: https://github.com/Gautam5514/Touch-Grass

Gautam5514 / Touch-Grass

🌿 WildQuest AI

Explore more. Scroll less. Your next adventure is outside.

WildQuest AI turns a short walk into a nature-discovery game. Get a handful of small missions — find a green leaf, a flower, a tree trunk, the sky — photograph what you find, and an open-weight vision model running entirely on your own device checks each photo. When you finish, the app tells you to put the phone away.

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

📸 Screens


Home	Explore	Missions	Result

Complete	Journal	Settings	Desktop

Screenshots use real photos with a stubbed score from the mock-AI test build, so they're deterministic. Real model behavior is covered by tests/e2e/real.spec.ts and docs/EVALUATION.md.

📑 Contents

View on GitHub

How I Built It

The verification core runs entirely on-device, with open-source AI doing all the work — no paid vision API, no inference server, and no uploaded photos.

Model: Xenova/clip-vit-base-patch32, a quantized ONNX port of OpenAI's open CLIP ViT-B/32 (~90MB), run through Transformers.js and ONNX Runtime Web (WASM) inside a Web Worker so the UI never blocks.
Matching: each captured photo is scored against text prompts for the target, its aliases, visual look-alikes, and the other missions' targets. A decision rule (the target must rank first, score at least 0.45, and lead the next-best match by at least 0.15) returns matched, uncertain, mismatch, or error.
Stack: Next.js 16, React 19, TypeScript, Tailwind CSS 4, Dexie (IndexedDB) for local history, a service worker for the PWA/offline cache, and Vitest + Playwright for unit and end-to-end tests, including real-model end-to-end runs.
Because the model ships with the app and runs locally, the only outbound network call in the whole experience is the one-time model download from Hugging Face. Everything else, including every photo you take, never leaves your device.

Why Does Open Innovation Matter?

An open-weight model is what makes the core promise of this app possible: photos that never leave your phone. A closed, API-based vision model would mean sending every "is this a leaf?" photo to a server — which breaks the privacy story, adds per-request cost and latency, and makes offline use impossible. Because CLIP's weights are open and small enough to quantize down to a browser-friendly ONNX build, I could ship the entire verification pipeline inside the static app bundle, test it deterministically offline, and let anyone self-host or fork the project without touching a provider's API key or billing dashboard. Open weights turned "an AI feature" into "a free, static, forkable PWA."

Prize Categories

Entering for the overall challenge prize.

DayBuddy — a daily companion I built for my friend Yashu

softGpt 9299 — Sun, 04 Oct 2026 10:48:51 +0000

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

What I Built

DayBuddy is a daily companion I built for my friend Yashu. Her routine kept slipping — sleeping past her alarm, skipping meals without noticing, losing track of what she meant to get done, and nobody actually checking in on how her day went.

DayBuddy wakes her up by name and reads out a short plan built around her real wake time, food and exercise preferences, and whatever is on her list that day — out loud, in plain English or Hinglish, whichever she's comfortable in. She can talk to it instead of typing: add a task, do her evening check-in, or ask "why was I tired this week?" by voice. Each night's check-in quietly shapes tomorrow's plan — a missed workout becomes a lighter start, a skipped meal gets a gentle nudge, never a guilt trip.

It's built so a bad network day never breaks her morning: no AI reachable, no database reachable, no voice service reachable — the app still answers with sensible defaults, every time.

Demo

Live app: https://daybuddy-yashu.onrender.com
API: https://daybuddy-yashu-api.onrender.com

(Both run on Render's free tier, so the very first request after a quiet period can take 30–50s to wake up — give it a moment.)

Code

https://github.com/Gautam5514/DayBuddy_hack

How I Built It

Frontend — Next.js 16 (App Router), React 19, Tailwind CSS v4, shipped as a static export.
Backend — Node.js, Express 5, with Zod validating every request and every model response.
Open-source AI — Gemma 4 (Google's open-weight model), called through the free tier of the Gemini API. It writes the daily plan (greeting, schedule, meal and exercise suggestions, one specific tip) and answers questions about Yashu's own saved check-ins — only from what she's actually written down, never a guess. If Gemma is slow, unreachable, or returns something unusable, a deterministic rule-based planner answers instead, so the app never visibly breaks.
Voice — ElevenLabs — Scribe turns her spoken tasks, check-in notes and questions into text (it understands Hinglish with no extra setup), and the text-to-speech voice reads the daily plan, answers, and a brand-new daily wake-up alarm out loud. The alarm rings once a day at her saved wake time while the app is open, speaking her greeting and that day's pending tasks — with a browser-voice and a plain tone as fallbacks if the voice service is ever unreachable, so she's never met with silence.
Database — MongoDB Atlas, with an in-memory store as an automatic fallback and a background retry loop, so a flaky connection never takes the whole app down.
Observability — Sentry Agent Tracing, tracing every planning and "ask" call using the gen_ai.* semantic conventions — one span per agent run, one child span per model call, with latency and token usage. Nothing else: no prompts or answers are ever recorded, because they're someone's private check-ins.
Deployment — Render, a free Node web service for the API and a free static site for the frontend, defined as one render.yaml Blueprint.
GitHub Copilot, configured with a .github/copilot-instructions.md file so Copilot's coding agent always has the real project context — the stack, the "never break on a failed service" rule, and the "no implementation jargon in the UI" rule — plus GitHub Actions (.github/workflows/ci.yml) that lints and tests the backend and lints and builds the frontend on every push.

Why Does Open Innovation Matter?

Because Gemma is open-weight and free to call through the Gemini API's free tier, I could build this exactly the way a friend building for a friend actually would: no budget, no enterprise contract, no vendor lock-in, nothing stopping Yashu from running her own copy later if she ever wants to.

Being able to see the full shape of a prompt and its response, instead of a black box, is what let me build a rule-based fallback planner that mirrors the AI one closely enough that Yashu — or a judge — usually can't tell which one answered. That same visibility is what made the Sentry Agent Tracing genuinely useful here: it traces real call structure and real token counts, not a guess at what a closed API might be doing behind the scenes. Openness is the reason the whole app can promise "it never breaks" instead of just hoping it won't.

Prize Categories

Best Use of Gemma
Best Use of ElevenLabs
Best Use of MongoDB Atlas
Best Use of Sentry Agent Tracing
Best Use of Render
Best Use of GitHub Copilot

Thanks for reading — and happy Hacktoberfest!

SplitEase - I Built an AI-Powered Bill Splitter So My Roommates Would Stop Owing Me Money

softGpt 9299 — Sun, 04 Oct 2026 07:44:53 +0000

This is a submission for the MLH x DEV Writing Challenge

What I Built

SplitEase (live at split.elitecrew.online) is a zero-paywall expense-splitting platform for roommates, friend groups, and trips — built to kill the awkward "I'll pay you back later" conversation for good.

The idea came from a very real, very annoying problem: tracking hostel bills, flat rent, and trip expenses across a WhatsApp group and a mental spreadsheet that nobody actually updates. SplitEase replaces that chaos with one place where every group tracks who paid, who owes, and how to settle up with the fewest possible transfers.

Core features:

Groups for everything — unlimited groups and members, with roommate, trip, and one-off "Quick Split" modes
Flexible splitting — equal, percentage, shares, or exact-amount splits
QR, link & email invites — get a group started in seconds, no signup friction
Real-time group chat — payments and settlements are recorded directly inside the conversation, so there's no "wait, did you actually pay?"
Minimum-transfer settlement suggestions — the app does the math to simplify 18 messy bills into just 2 transfers
Receipt photos + a built-in AI assistant — attach a receipt and let the assistant help itemize it
Live balance dashboard & spending charts — see exactly where the group's money went, by category, by month
Secure OTP login, with TLS in transit and encryption at rest (security practices inspired by OWASP)

It's completely free — no per-member fees, no trial period, no feature gates — and it runs both as a web app and as a mobile app on Google Play.

Demo

🔗 Live app: https://split.elitecrew.online

📱 Also on Google Play (React Native app for Android & iOS)

Partner Technologies

SplitEase is a full-stack build end to end:

Frontend: Next.js, React, TypeScript, Tailwind CSS, Framer Motion, Recharts, Axios
Backend: Node.js + Express, MongoDB (via Mongoose), JWT authentication, Socket.io for real-time chat and live balance updates
Infrastructure: Firebase, Cloudinary for receipt/image storage, Nodemailer for email delivery
AI & OCR: OpenAI and Google Gemini power the in-app assistant, with Tesseract.js handling optical character recognition on receipt photos — together they turn a photographed receipt into itemized, split-ready expense data
Mobile: React Native (Android & iOS), Firebase
Quality: Jest test suites, CodeQL static analysis, and CI running fast-check property-based security tests on every push

Hackathon Experience

Building SplitEase at an MLH hackathon was less about chasing a trendy idea and more about finally fixing a problem I'd been living with for years — the awkward "who owes who" math that follows every trip, every shared flat, every group dinner. Hackathon weekends have a very specific energy: a hard deadline, a working demo as the only acceptable outcome, and no time to overthink the stack. That pressure is exactly what turned "I should build an expense splitter someday" into a real, deployed product with real-time chat, AI-assisted receipts, and a live settlement engine in one weekend.

The biggest takeaway was how much a tight hackathon timebox forces good scoping — deciding what's a "coming soon" feature (multi-currency, CSV export, UPI payouts) versus what has to work flawlessly on demo day (splitting, settling, chatting). That discipline is still shaping how I'm building out SplitEase today.