DEV Community: Anshika Agarwal

[Boost]

Anshika Agarwal — Sat, 24 Oct 2026 14:24:47 +0000

Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady Submission 🦥

Anshika Agarwal

Oct 24

🦥 SlothSummarize: Let AI Read It So You Don't Have To

#devchallenge #hf26challenge

4 min read

🦥 SlothSummarize: Let AI Read It So You Don't Have To

Anshika Agarwal — Sat, 24 Oct 2026 14:23:41 +0000

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

🦥 What I Built

Meet SlothSummarize — an AI-powered summarizer that does the reading so you don't have to!

We all deal with lengthy emails, meeting notes, chat conversations, and articles that take forever to read. I wanted to build something that makes understanding long text effortless.

SlothSummarize lets you paste any text and instantly get a 2–3 sentence TL;DR and up to five actionable next steps.

What makes it special?

📝 Instant TL;DR: Get straight to the important points.
✅ Action Items: Extract concrete next steps from lengthy text.
🎭 Three Summary Styles: Lazy (casual), Formal (professional), and Brutal (no-fluff).
🔒 Privacy First: AI inference happens locally in your browser.
💸 No API Keys or Subscription Costs: Run open-weight models on your own device.
🦥 Simple and Fun: A sloth-themed interface that makes summarization less boring.

Whether you're a developer catching up on documentation, a student reviewing notes, or a professional dealing with endless meeting transcripts, SlothSummarize helps you spend less time reading and more time doing.

The idea is simple: Less reading. More doing. Maximum laziness.

🎬 Demo

Live Demo: [https://slothsummarize.onrender.com/]

Here's how it works:

Open SlothSummarize in a compatible browser.
Select your preferred AI model.
Paste your text and choose a summary style.
Click summarize and let the sloth do the work!
Get your TL;DR and action items in seconds, depending on the model and your device.

💻 Code

GitHub Repository: [https://github.com/anshika361/SlothSummarize]

The project is built with a simple, lightweight structure:

SlothSummarize/
├── index.html
├── style.css
├── app.js
├── llm-worker.js
├── sloth_mascot.png
└── README.md

No complicated setup, no backend infrastructure, and no API keys required for inference.

⚙️ How I Built It

The biggest question I wanted to explore was:

Can we build a useful AI application that runs entirely in the browser without sending user data to an external AI service?

The answer is SlothSummarize!

🧠 Open-Source AI with WebLLM

I used WebLLM, an open-source inference engine that runs language models directly in the browser using WebGPU.

The application supports these open-weight models:

Phi-3.5 Mini Instruct: The default model for high-quality summaries.
Llama 3.2 1B Instruct: A smaller model for lightweight use.
Llama 3.2 3B Instruct: An alternative balancing model size and output quality.

Users can choose a model depending on their device capabilities and preferences.

🏗️ Technology Stack

Frontend: HTML, CSS, and vanilla JavaScript
AI Runtime: WebLLM
Models: Phi-3.5 Mini Instruct and Llama 3.2 1B/3B Instruct
Inference: Local browser execution using WebGPU
Design: Sloth-themed UI, glassmorphism, and Hacktoberfest-inspired colors

🔄 How It Works

The user pastes text into the application.
JavaScript prepares the summarization prompt based on the selected style.
WebLLM passes the prompt to the selected local language model.
The model generates a concise summary and relevant action items.
The results are displayed directly in the browser.

There is no application backend involved in the inference process.

The model files are downloaded when required and cached for subsequent use. After the initial setup, the application is designed to support offline use, provided the necessary assets and model files are available locally.

🌍 Why Does Open Innovation Matter?

Open innovation makes AI more accessible, customizable, and privacy-conscious.

Many AI applications rely on external APIs, which can introduce recurring costs, network dependencies, and concerns about sharing sensitive information.

I wanted SlothSummarize to take a different approach.

🔒 Privacy Without Compromise

People often summarize private emails, internal discussions, and meeting notes. Processing their text locally means it doesn't need to be sent to a third-party inference service.

💸 AI Without Per-Request Costs

There are no paid inference API calls or token-based charges. Users can run supported models on their own hardware.

🔧 Freedom to Experiment

Open-weight models allow experimentation with different model sizes and summarization styles without being tied to a single proprietary AI provider.

🌱 Innovation Without Heavy Infrastructure

A useful AI tool doesn't always need a complex backend, cloud deployment, or expensive infrastructure.

With WebLLM and open-weight models, SlothSummarize demonstrates how a simple web application can provide AI-powered functionality directly on a user's device.

Open innovation made it possible to build a tool that is lightweight, customizable, and designed with privacy in mind.

🦥 The Lazy Payoff

Imagine receiving a long meeting transcript with several decisions, deadlines, and action items.

Instead of reading every line and manually identifying what matters, you paste it into SlothSummarize and get a concise overview.

Before	After
Read lengthy email threads	Scan the key points
Review entire meeting notes	Get a short TL;DR
Manually find follow-up tasks	Extract suggested action items
Rewrite summaries for different audiences	Switch between three styles
Send private text to a cloud AI API	Process text locally

The actual time saved depends on the text length, model, and device performance. Larger models may take time to download and generate results, especially on less powerful hardware.

The best part? Once the model is cached, you can reuse it without downloading it again every time.

It's a small productivity improvement, but those little saved moments add up.

Less time reading. More time building. That's the sloth philosophy. 🦥

🏆 Prize Categories

Hacktoberfest Open-Source AI Challenge — Week 3: Slow and Steady

SlothSummarize aligns with the challenge by combining open-weight AI, open-source inference technology, and practical automation to reduce everyday effort.

Add any specific partner prize categories you are entering after confirming the current challenge rules.

Thanks for checking out SlothSummarize!

If you like the idea, explore the code, share feedback, or contribute to making the sloth even smarter.

Let AI handle the reading while you enjoy the slow and steady life. 🦥💚

Hacktoberfest #OpenSource #AI #WebLLM #WebGPU #JavaScript #PrivacyFirst

InvoicePilot: A Private Invoice Desk for Freelancers

Anshika Agarwal — Thu, 15 Oct 2026 21:17:17 +0000

InvoicePilot: A Private Invoice Desk for Freelancers

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

What I Built

InvoicePilot is a local-first invoice organizer for freelancers and solo business owners who are tired of manually sorting client bills and receipts. Paste invoice text—or import a .txt file—and it pulls out the vendor, client, invoice number, date, subtotal, tax, total, and line items. It groups detected items into categories and includes a check that compares the invoice total with subtotal plus tax.

The person I built this for is a freelancer who wants a quick expense snapshot without signing up for another cloud accounting service. InvoicePilot is a prototype, not a business with paying customers yet. A possible paid product would be a one-time purchase or a small subscription for freelancers who value a private, lightweight workflow; I have not validated pricing with users.

Demo

Live demo: InvoicePilot on Render. Click Try sample, confirm the hosted-demo privacy notice, then click Organize invoice to see the dashboard, category breakdown, reconciliation check, and export/save actions. This public demo sends submitted text to the Render service for processing, so use fictional/test data only—not real invoices.

For local use, install the dependencies, run python app.py, and visit http://127.0.0.1:5000. InvoicePilot accepts pasted text and .txt files; it does not do PDF or image OCR.

Code

Repository: github.com/anshika361/InvoicePilot

The app is built with Python and Flask. The code includes the invoice parser, the local Ollama integration, and the browser interface for CSV export and browser-local saves.

How I Built It

InvoicePilot has two local processing paths:

A deterministic parser extracts common invoice fields and line items. It also assigns simple categories such as design, development, travel, and software.
If Ollama is running locally with the llama3.2 model installed, the app can ask that open-weight model to help structure invoice text. If Ollama is unavailable, the built-in parser remains usable without a cloud AI request.

The model is not the calculator: numeric totals parsed from the invoice source stay authoritative even if the model returns a different number. The dashboard compares subtotal plus tax with the stated total and shows a warning when they do not match. That’s important for financial data, where a plausible but incorrect number is worse than an obvious warning.

The interface also supports CSV download, copyable summaries, and saving up to 12 invoice summaries in the browser’s local storage. Those saved summaries stay in that browser; they are not a shared account or a server-side database. Local mode processes invoice text on the user’s device. The public Render demo is different: submitted text is sent to the hosted service and should only be used with fictional/test data.

For this development run, Ollama was not installed, so I verified the fallback path—not a live model inference. I added a test that simulates a conflicting model total to check that it cannot override the invoice’s parsed total. The project’s seven tests pass. I still need to run and record a real Ollama-backed invoice before describing the open-model extraction as demonstrated.

Why Does Open Innovation Matter?

Invoices contain names, client relationships, and money. In local mode, invoice text stays on the user’s device instead of going to a third-party AI service. An open-weight model can run on hardware the user controls, and the model can be swapped or adapted as invoice formats and user needs change. There is no per-request model API bill in this local setup, although running a model still has hardware and electricity costs. The public Render demo is a convenience for trying the sample workflow, not a private place to process real customer invoices.

The fallback also matters: the basic workflow does not depend on an account, network connection, or paid model endpoint. Open tools make it possible to inspect and change the processing path instead of being locked into one provider’s pricing or data policies.

I’m keeping the boundary clear: the current app supports local Ollama inference, but the sample session I verified used the deterministic fallback because Ollama was unavailable. The open-model path needs a hands-on test before I can claim it improved extraction quality over the fallback.

Groundline

Anshika Agarwal — Sun, 11 Oct 2026 11:42:28 +0000

Hacktoberfest: Maintainer Spotlight

Anshika Agarwal

Oct 11

Groundline: a two-minute outdoor briefing that gets you outside

#hf26challenge #opensource #devchallenge #hacktoberfest

2 min read

Groundline: a two-minute outdoor briefing that gets you outside

Anshika Agarwal — Sun, 11 Oct 2026 11:42:08 +0000

Built for the Touch Grass week of Hacktoberfest
Most apps are designed to keep you in. Groundline is designed to get you out.
You open it, tell it two things (how long you have and what kind of outing you want), and it hands you one pocket-sized card:

📍 A destination, a real park near you
👃 A sensory cue, something to notice when you get there
⏱️ A timer, then the phone goes back in your pocket

No feed, no infinite scroll. You do one quick check, then leave.

How it works

Before the model writes a single word, Groundline gathers real local data:

OpenStreetMap supplies verified nearby parks and green spaces, so it never sends you somewhere that doesn’t exist.
Open-Meteo supplies live weather, so a 20-minute walk is planned around the rain that’s about to arrive.
Backboard routes the request to a model and keeps assistant memory, so the app knows which places you’ve already visited and can nudge you toward somewhere new.
An open-weight model (Gemma, Llama or Qwen) writes the card from that grounded prompt.

The model doesn’t invent the destination. It only turns facts into a short, human-sounding card.

Why Backboard is central

Two things make the card feel personal instead of generic:

It remembers. Places you’ve already been get deprioritized, so the app keeps nudging you somewhere new.
It’s grounded. The final prompt is built from real OSM and weather data, which keeps the model from hallucinating a lake.

Backboard also makes swapping between open-weight models easy, so you can try Gemma, Llama or Qwen and see how each one changes the voice of the card.

No model? No problem

If the model is unavailable, a fallback almanac path still produces a card from the same local data. The core promise (a destination, a cue and a timer) survives without AI.

Open source and easy to adapt

Groundline is lightweight and meant to be forked. Swap in your city’s data, change the tone of the cards, or plug in a different model.

👉 Github Repo: Groundline

If you take a walk because of it, that’s the whole point. 🌳