DEV Community: Vrushali

Google Play is making DEX code optimization mandatory for eligible Android apps starting February 2027.

Vrushali — Fri, 30 Oct 2026 13:27:10 +0000

🚨 Android Developers: Is your app ready for February 2027?

Google Play is making DEX code optimization mandatory for eligible Android apps starting February 2027.

But what does this actually mean for your app?

In my latest article, I explain:

🔹 What DEX optimization means

🔹 Code shrinking, optimization & obfuscation

🔹 Which apps are affected by the new requirement

🔹 How to enable R8 and ProGuard

🔹 Common mistakes developers should avoid

🔹 A quick checklist to prepare your app

I’ve tried to explain everything in simple language with practical examples.

If you're an Android developer, this is worth understanding before the deadline!

📖 Read the full article:

https://medium.com/@vrushalidev/google-play-dex-optimization-mandatory-feb-2027-make-your-app-smaller-faster-and-safer-22e7303989c2

💬 Have you checked your app's DEX optimization scores yet?

AndroidDevelopment #AndroidDev #GooglePlay #Kotlin #MobileDevelopment #R8 #AppOptimization

A2UI Looks Great, But Should Android Developers Use It Yet? 🤖

Vrushali — Thu, 29 Oct 2026 13:37:26 +0000

AI is changing how we build apps, but what if AI could decide which UI components to display while our app stays in control of the design?

That’s the idea behind A2UI (Agent-to-UI).

In my latest article, I explain A2UI in simple terms, using a restaurant analogy, and explore:

🧩 How A2UI uses a catalog of approved UI components
🔐 Why controlled UI generation can be safer
📱 How it fits into Android and Jetpack Compose
⚠️ My concerns about cost, offline support, debugging, and maturity
🚀 How Android developers can start experimenting with it

My take? It’s an exciting idea, but I’d start with one simple screen rather than redesigning an entire app around it.

If you're learning Android development or exploring AI-powered interfaces, I'd love to hear your thoughts!

👉 Read the full article on Medium:

https://medium.com/@vrushalidev/a2ui-looks-great-but-should-you-use-it-pros-and-cons-940a78191822

android #kotlin #ai #jetpackcompose

💻 My Claude Desktop folder quietly grew to 12 GB. I got 11.5 GB back!

Vrushali — Tue, 27 Oct 2026 14:09:12 +0000

💻 My Claude Desktop folder quietly grew to 12 GB. I got 11.5 GB back!

I use Claude Desktop regularly for sandbox tasks, running scripts, and building things. Everything worked fine until my Windows C: drive started running low on space.

After investigating, I discovered that most of the storage was being used by the virtual machine files inside AppData\Roaming\Claude.

I dug deeper, figured out what could be safely cleaned up, and documented the process in a step-by-step guide.

In this blog, you'll learn:
🔹 Where Claude Desktop's disk space goes

🔹 Which folders you can clean up

🔹 How to reclaim space using PowerShell

🔹 What to back up before deleting anything

The best part? I recovered around 11.5 GB without deleting my chat history or settings.

If you're a Windows user who regularly uses Claude Desktop for sandbox tasks, this might help you too!

📝 Read the full guide: [https://medium.com/@vrushalidev/my-claude-desktop-folder-quietly-grew-to-12-gb-heres-how-i-got-11-5-gb-back-6e5f052d6e67]

Have you ever discovered an app quietly consuming gigabytes of storage? Share your experience in the comments!

#ClaudeAI #Windows #AI #DeveloperTools #TechTips

Sloth Gist: drop in audio, video or text and get the gist, all on your own laptop

Vrushali — Wed, 21 Oct 2026 14:37:55 +0000

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

What I Built

I have a pile of things I mean to get to: voice notes, meeting recordings, lecture videos, long articles, exported chats. I never get to them, because each one costs 10 to 60 minutes I don't have.

Sloth Gist does the slow part for me. I paste the path to a recording or a folder of them (or paste some text), press "Summarize while I nap", and come back to a short digest:

a one-line summary of each item
key points (3 to 6 bullets) when I want more than a line
a to-do checklist with anything that needs a reply or a date

It works on audio (voice notes, calls, meetings, podcasts), video (only the soundtrack is read) and plain text (.txt, .md or pasted). Summaries are written in the language of the input, with English, Hindi and Marathi built in and auto-detect by default.

Everything runs on my computer. Nothing is uploaded.

Demo

I pointed Sloth Gist at my screen-recordings folder (five .mp4 demos, about 6 minutes of audio in total) and then pasted a Jetpack Compose meeting note.

1. The Drop Zone. Paste a folder or file path, or switch to the Text tab.

2. Settings. Only Whisper models already on the laptop are offered, and the AI model list comes from local Ollama.

3. A folder of recordings, summary plus key points.

4. The sloth inches along while it works.

5. Text works too, with no Whisper step.

6. The digest. The Compose note became one summary line, five key points and a to-do for Rahul's Friday deadline. Each video got its own card.

Code

vrush1588 / sloth_gist

Local-first audio, video and text summarizer. Drop recordings, meetings or lectures and get a short summary, key points and to-dos, all on your own computer with open-weight models (Whisper + Ollama + Gemma). Nothing is uploaded.

Sloth Gist 🦥

Drop in audio, video or text and get the gist, all on your own laptop.

Sloth Gist transcribes speech with faster-whisper, or reads pasted text and .txt/.md files, then turns it into a short summary, key points and to-dos with a local Ollama model. Nothing leaves your computer. Video frames are not analyzed.

Screenshot: Add a screenshot of the Sloth Gist app here.

Why open models?

Works offline: download models once, then keep your recordings on-device.
Private: no cloud transcription or summaries; transcripts are not saved.
Swappable: choose a Whisper size and any model available in local Ollama.
Free to run: open models have no per-minute or per-summary API fees. Your computer supplies the compute.

Quick start

Install Ollama and pull the default summary model:
```
ollama pull gemma3:4b
```

Install the Python dependency:

python -m pip install -r requirements.txt

Start the web app:
```
python -m sloth_gist.server
```
…

View on GitHub

Python 3.11+, standard library only on the server side, plus faster-whisper. Summaries come from a local Ollama. The interface is one offline web page with no CDN, no web fonts and no external requests.

How I Built It

The whole pipeline is open-weight models on a laptop:

Speech to text: faster-whisper (Whisper) transcribes audio and the soundtrack of video files. Transcripts stay in memory and are never written to disk.
Summaries and key points: gemma3:4b served by Ollama. Any Ollama model works; Gemma models are listed first because they handle Hindi and Marathi better than most small models.
Long recordings: a one-hour lecture is too long for a small model in one pass, so the text is split into 5,000-character chunks, each chunk is summarized, and those summaries are combined into the final gist. Key points and to-dos are merged and de-duplicated across chunks.
Local server and UI: a tiny server that only binds to 127.0.0.1, and a calm cream-and-sage page (designed in Stitch, then simplified and rebuilt to work fully offline). While it works, a sloth slowly inches along the progress bar.

Privacy is built in, not promised:

The app refuses to talk to any model server that isn't on the same machine. It also refuses redirects away from localhost and ignores proxy settings.
The app never downloads anything while it runs. You fetch the models once (ollama pull gemma3:4b plus a one-line Whisper download), and after that it works with Wi-Fi off.
Summaries are paraphrased: any line that copies six or more words in a row from the original is dropped, so the digest doesn't leak whole sentences.
Only the short digest is saved, with file permissions set so only my user account can read it, and a Wipe digest button deletes it.
Original files are only read, never copied, moved or changed.

Why Open Innovation Matters Here

This project doesn't make sense with a closed model, because the input is the most private stuff people have: meetings, calls, family voice notes, work documents.

It keeps recordings off servers I don't control. With a cloud API I would have to upload hours of audio. Here the audio never leaves the machine, and anyone can check by switching Wi-Fi off and running a digest.
It works with no internet. After a one-time model download, it runs on a plane, in a lecture hall or on a patchy connection.
I can swap models. Whisper tiny through medium trades speed for accuracy, and any Ollama model can write the summary. That kind of testing is easy with open weights and awkward or expensive with a closed API.
It costs nothing to run. No API key, no per-minute transcription bill, no usage limits. Processing a long backlog costs only electricity and patience, which suits the slow-and-steady theme.
I control the behavior. I can change the prompt, the chunk size or the output style without waiting for a vendor.

One note on honesty: Whisper is MIT licensed, but some models (Gemma, Llama) are open-weight under their own license terms, not standard open-source licenses. My code is MIT. The models keep their own licenses.

Where It Worked Better Than a Closed Approach

Privacy by design: zero bytes of audio or text are sent anywhere.
Predictable cost: the demo above (about 6 minutes of video plus a 300-word note) cost nothing, and a backlog of hours would cost nothing too.
Good enough on small hardware: the demo ran on CPU with the small Whisper base model and a 4B summary model, and still produced useful summaries, key points and to-dos.

Honest Limits

You download the models once, by hand, while online.
Small models make small-model mistakes. They are good for the gist, not a legal record, so I keep the original recording. In the demo, the Compose note had two follow-ups with dates, and the digest caught only one of them. Whisper base also misheard a word in one video.
If a recording has no clear speech (screen audio or music only), you get "No speech detected" instead of a summary.
It reads only what is said or written. For video it doesn't look at the frames.
It's CPU-friendly but not instant: a long recording takes a while, which is the point.

What's Next

A watch-folder mode so new recordings get summarized overnight, and a morning digest file waiting when I wake up.

Thanks for reading, and for the sloth. 🦥

Stitch Desk is a local-first order assistant for boutiques and tailors.

Vrushali — Wed, 14 Oct 2026 14:10:51 +0000

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

What I Built

Stitch Desk is a local-first order assistant for boutiques and tailors.

Many small tailoring shops still run on paper notebooks, loose receipts, and WhatsApp chats. A customer's measurements are in one place, the delivery date is on a sticky note, and the balance is in the owner's head. In busy seasons, that is where orders get lost and deliveries get late.

Stitch Desk turns that into one small app:

Note to order card: The owner types or pastes a messy note, like "Anna, bridal lehenga, boat neck blouse, deep U back, bust 36, waist 30, delivery 20 Nov, total 24000, advance 10000". A local AI model turns it into an editable card with the customer, garment, design notes, measurements, delivery date, total, advance, and balance. The owner checks it before saving.
Orders board: Orders sorted by delivery date, with status chips (New, Stitching, Trial pending, Ready, Delivered), a "due this week" count, and the total balance still pending.
Customers: Orders grouped by customer, with a saved phone number, the latest measurements for each garment, and order history.
WhatsApp message drafts: "Ready for trial", "Order ready", and "Balance reminder" messages the owner can edit and open in WhatsApp.
Design search: The owner describes an outfit ("bridal lehenga blouse, boat neck, deep back"), sees matching pictures, and links up to three as references on an order.

Who would pay for it: small boutiques and tailors who keep orders and measurements in notebooks and chats, and who lose time (and sometimes money) chasing details and balances. I have not set a price. I describe below what a tailor said when I showed it to them.

Demo

Screenshots: ## Demo

All screenshots use fictional sample data. The banner is an AI-generated illustration.

Code

vrush1588 / stitch-desk

A local-first order assistant for boutiques and tailors. Turn customer notes into editable order cards, organize contact details and measurements, draft WhatsApp messages, and find outfit design images for order references.

Stitch Desk

Stitch Desk is a local-first order assistant for boutiques and tailors: turn a messy customer note into an editable order card, keep customer contact details and measurements together with WhatsApp message drafts, and search for outfit design pictures to link as order references.

Features

Create order cards from a pasted note with local AI, or fill the order in by hand.
Track delivery dates, order status, advances, balances, and design references.
Group saved orders by customer, save contact numbers and measurements, and create editable WhatsApp message drafts.
Search Google Images through SerpApi and attach up to three linked design references to an order.
Keep orders, customer details, and in-progress order drafts in this browser's local storage.

Who it's for

Stitch Desk is for small boutiques and tailors who keep orders, measurements, and delivery dates in notebooks and WhatsApp chats. They get a quick way to turn a spoken…

View on GitHub

The repo has a README, setup steps, an MIT license, and an .env.example with no secrets.

How I Built It

Stack: React + Vite for the app, a small Node + Express server for design search, Ollama running Gemma (gemma3:4b) on my own laptop, SerpApi for image search, and the browser's localStorage for orders and customers. I built it one feature at a time with GitHub Copilot prompts, and committed after each step.

Where Gemma is used (three jobs):

Order cards. The app sends the owner's note and today's date to Gemma and asks for JSON only: customer, garment, design notes, measurements, delivery date, total, and advance. The prompt says never to invent values, and to leave a field empty if the note does not say it. The result is shown in an editable form with the label "AI draft, please check", and the balance is computed in code.
Message wording. The code builds each WhatsApp message from a fixed template with the customer's name, garment, delivery date, and balance. Gemma only rewrites it in a warmer tone. Then the code checks that every number and date from the template appears unchanged in Gemma's reply. If anything is missing or changed, the app uses the plain template instead.
Search queries. Gemma turns the owner's request into two short search phrases. The code then removes any phrase containing digits or a saved customer's name, so no private details reach the search service.

SerpApi runs the image search through my small server, so the API key never reaches the browser. Results are cached, so the same search never costs a second credit, and there is a per-session limit. The app saves only the thumbnail link, title, and source page for each reference, never the image itself.

If the model is off, the app does not break. The order form becomes a manual form, and messages use the plain template.

What I learned about using a small model for money-related data

The biggest risk with an order app is a wrong number. A small model can misread or change figures, and a wrong balance in a message to a customer is a real problem. So I did not trust the model with anything that must be exact:

The balance is calculated in code, not by the model.
The model never writes amounts or dates into messages. It only rewords around them, and the code verifies them.
Every AI result is shown for the owner to edit before it is saved.

Why Does Open Innovation Matter?

The cost stays near zero per order. Gemma runs on the owner's own machine, so there is no per-note or per-message AI charge. For a small shop where each order brings in a small amount, a metered AI bill per card would eat into the margin. The only metered cost in my build is the optional image search, and I cache it to keep that low.
Customer details stay on the device. Names, phone numbers, and body measurements are sensitive. Notes and measurements are processed by a model on the owner's laptop and stored in the browser, and are not sent to a hosted AI service. Only short design-search phrases leave the machine, and the code removes names and digits from them.
I could change how it behaves. Because I control the prompts and the model setting, I could add strict rules (never invent values, keep numbers exactly as written) and swap the model by changing one setting.
It is honest about limits. Running the model myself made it clear what a 4B model can and cannot do. I describe the mistakes it made below and in the repo's README.

My Agent Session

I built Stitch Desk with GitHub Copilot's agent mode, using one prompt per feature and committing after each step so I could test it before moving on. I did not save a full session transcript, so here are the key prompts (shortened) and what I checked after each one.

1. Base and layout

Start from my existing React + Vite project, rename it "Stitch Desk", remove the old features, keep the Ollama connection, JSON parsing helpers, fallback pattern and localStorage utilities, and create a mobile-first layout with bottom navigation: Orders, New, Designs, Customers. Show a "Local AI on / off" badge.

Check: Four tabs render correctly, and the badge status updates instantly when stopping or starting Ollama.

2. Note to order card (the core feature)

Send the owner's note and today's date to the local Gemma model and ask for JSON only (customer, garment, design notes, measurements, delivery date, total, advance). Never invent values, use null for anything missing, keep numbers exactly as written. Show an editable form labelled "AI draft, please check" with the balance computed in code. If Ollama is off, show an empty manual form.

Check: I tested 5 distinct note formats (complete note, missing total, missing measurements, scrambled number order, and a very messy shorthand note). 4 of 5 were fully correct; the model left the delivery date empty when I wrote only "Friday" without a specific calendar date, which correctly triggered the fallback rather than guessing.

3. Orders board

Show "due this week" and "balance pending" cards, filter chips, order cards sorted by delivery date with colored date chips, a bottom sheet to change status or record a payment, and an empty state.

Check: Orders sort accurately by urgency, and marking an order as "Delivered" instantly drops it from the pending balance total.

4. Customers and WhatsApp drafts

Group orders by customer, save a phone number and the latest measurements, and build messages from fixed templates filled in by code. Let Gemma only reword the tone, then verify in code that every number and date is unchanged. If anything changed, or Ollama is off, use the plain template.

Check: The recipient name, delivery date, and balance matched the order data precisely every single time. When I intentionally tweaked a number in a test prompt, the verification safeguard caught the discrepancy and cleanly defaulted to the plain template.

5. Design search with SerpApi

Add an Express server that calls SerpApi, keeping the key in .env, with caching and a per-session search limit. Let Gemma write two search phrases, and in code remove any phrase containing digits or customer names. Show up to 8 results and let the owner link up to 3 as references, storing only links and titles.

Check: Repeat searches loaded instantly from the cache, the API key never leaked to the frontend bundle, and turning off the backend server displayed a clean, friendly fallback message.

6. Screenshots and README

Write a script that loads fictional sample data and captures phone-sized screenshots into docs/images, then write a README that describes only features that exist.

My First User

I showed Stitch Desk to a tailor near me. They have not used it on real orders yet, so this is a first reaction and not a full test.

First reaction: "This looks useful. If I can manage customer measurements and stitching orders in one place, it could save me time."
What they liked: Storing customer measurements, tracking order status, and keeping track of delivery dates without relying on notebooks.
What they would change: No suggestions yet.
Would they pay? I have not asked about a price yet, so I will not guess one.

Honest Limits

Ollama has to be running on a computer for the AI features to work. Using it from a phone on the same network may need extra Ollama settings.
A small local model can still make mistakes with numbers, which is why every draft is reviewed and amounts are verified in code.
Orders live in one browser's local storage. There is no backup or sync yet, so clearing browser data would erase them.
Image search depends on a SerpApi plan, and the pictures belong to their original websites. The app links to them and does not copy them.
I tested with a small number of notes and one tailor's first reaction. I have not tested real daily use or a price.

Prize Categories

Best Use of Gemma

Stitch Desk runs gemma3:4b locally through Ollama for three jobs: turning notes into order cards, rewording message templates, and writing search phrases. In each case the code checks the output (balances computed in code, numbers and dates verified, queries filtered for names and digits), so the model helps without being trusted blindly.

Best Use of SerpApi

Design search uses SerpApi's Google Images API through a small server, with the key kept out of the browser. Gemma writes the search phrases, results are cached, and each result links to its source page. The tailor's customers often bring picture references, and this puts them next to the order.

Best Use of GitHub Copilot

I built the app by giving GitHub Copilot one prompt at a time and committing after each step: the layout and tabs, the order-card flow, the orders board, the customer screen, the message safeguards, the search server, and the README. Copilot was a development aid only, and it is not needed to run the app.

What's Next

Excel or file backup and a way to move data between browsers
Test more note styles, including notes in other languages
Try other open models and compare them with Gemma on real notes
Let the tailor try real orders for a week, then ask about price
A hosted demo for people who do not want to install Ollama

Petal & Leaf is a small web app that helps you look at your plants instead of your phone.

Vrushali — Wed, 07 Oct 2026 11:10:22 +0000

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

What I Built

Petal & Leaf is a small web app that helps you look at your plants instead of your phone.

I grow a few plants at home, including a tulsi (holy basil) on my balcony. I wanted an app for people like me with a few pots, not one that assumes a big garden. It works for anyone with a balcony, a rooftop, a few pots, or a friend's garden. It has three tabs:

Check Plant: Take a photo of a leaf, flower, or whole plant. A local AI model gives its best guess at the plant name, a one-line description, any visible problems, a care tip, and a confidence level. It's always labelled "AI guess, not a diagnosis."
Quests: Three small daily quests for your home plants (I tested with my tulsi), like touching the leaves gently, checking the stems for pests, or listening to the leaves rustle. You tap how the soil feels (Dry, Damp, or Wet) and get advice for that state, plus a seasonal tip.
Log: Everything you save is kept here with its date, photo, soil state, a short note, and an optional bird-sound recording. A "screen time vs outside time" tracker shows how much of the session you actually spent outside.

The idea is simple: the phone gives you a small job, then you put it away and go touch the soil. The app isn't limited to tulsi, and the photo check works on any plant, leaf, or flower.

Demo

Screenshots and photos: (https://dev-to-uploads.s3.us-east-2.amazonaws.com/uploads/articles/h5whpmjbzckv331ddduo.png)

Check Plant tab: a photo of tulsi identified as "basil (likely holy basil)" with medium confidence.

Quests tab: AI-generated quests, the soil picker, and Gemma's rephrased seasonal tip.

Log tab: a saved photo analysis, a 9-second bird recording, and quests completed.

Code

vrush1588 / petal_leaf

Screen-free nature quests powered by open-weight Gemma that runs in your browser, offline. 🌱

🌱 Petal & Leaf

Touch the soil. Look at the leaf. Spot the flower. Phone back in your pocket.

Petal & Leaf gives you small daily quests for your plants (touch the soil check the leaves, listen for a bird), then helps you log what you found When available, the open Gemma 3 4B model runs locally through Ollama to suggest quests, care tips, and photo observations. Built-in advice keeps working when Ollama is unavailable.

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

App screenshots

Check Plant	Quests

Nature log

Gemma use cases

Petal & Leaf connects to the local gemma3:4b Ollama model for:

Plant photo checks: suggest a likely plant, describe visible details mention visible issues, and offer a photo-specific care tip. This is an AI guess, not a diagnosis.
Daily quest planning: create three short, hands-on Tulsi quests using the selected soil state, season…

View on GitHub

The repo has a README and an MIT license.

How I Built It

Stack: React + Vite, Ollama running Gemma (gemma3:4b) on my own laptop, and browser localStorage for the log. I built it one feature at a time with GitHub Copilot prompts, committing after each step.

Where Gemma is used:

Photo analysis. The app resizes the photo and sends it to Gemma through Ollama's /api/chat endpoint. It asks for a JSON reply with the plant, a short description, issues, a tip, and a confidence level. The prompt tells it never to claim certainty.
Daily quests and soil advice. Gemma writes three quests from the plant, the soil state, the season, and where I am (my balcony or a friend's garden).
Friendly seasonal tips. I keep a small table of tulsi tips for each season and let Gemma rephrase it in a friendly voice. The facts come from my table, and Gemma only handles the wording.

Safety net: If the model is off or returns bad JSON, the app falls back to simple built-in rules, so it never breaks.

What went wrong (and what I changed)

Running Gemma in the browser failed. My first plan was fully in-browser Gemma through MediaPipe, so a phone could run it with no laptop. The model wouldn't load and the app showed a fallback message. I switched to local Ollama. The app now needs my laptop, so it isn't truly offline on a phone yet.
The first advice was vague. With the soil set to Wet, the AI said something like "maintain consistent soil moisture," which isn't helpful. I made the soil state a strict rule in the prompt and added a code check so wet soil never gets a "water it" suggestion.
The quests repeated themselves. Two of the three were about pests. I changed the prompt to require different kinds of quests: one about the soil, one about the leaves, and one about smelling or listening.
I almost built the wrong thing. My first idea was a bird-call identifier. Then I realised birds stop singing the second you press record, so I made the plant check the main feature. Bird sounds became an optional quest where you record a clip and note what you heard.

Why Does Open Innovation Matter?

My photos and notes stay on my machine. Pictures of my plants and my log go to Gemma on my own laptop, not to someone else's server.
It costs nothing to run. No API key and no per-photo charge, so I could take as many test photos as I wanted.
I could change how it behaves. Because I control the model and the prompts, I tightened the soil rule and fixed the repeated quests as soon as I saw the problems.
I could see the limits. Running the model myself made it clear what a 4B model can and can't do, which brings me to the honest part below.

Honest Notes: What Worked and What Didn't

Gemma named my tulsi photo as "basil (likely holy basil)" with medium confidence. It got the plant family right and was cautious about the exact type.
On a bouquet of roses, it said "roses" and "none noticed" for issues. Its care tip about drainage was generic and not tied to anything visible in the photo.
"No visible issues" from a small model shouldn't be trusted blindly. That's why every result carries the "not a diagnosis" label.
Touch Grass field test: I tested on my balcony. Screen time: 5 min. Outside time: 20 min. I did: touched the soil, checked the leaves. Did you hear a bird, or only rustling leaves?
Limits: It needs Ollama running on a laptop, I tested it mostly on tulsi, and the soil state is tapped by hand because moisture can't be judged reliably from a photo.

My Agent Session

Example prompts used with GitHub Copilot:

“Create a mobile-first React + Vite plant-care app with a soft pastel green theme, daily Tulsi quests, and a local observation log.”

“Use my local Ollama gemma3:4b model to generate safe daily quests and analyze plant photos. Resize images before sending, parse JSON safely, and keep built-in advice as a fallback.”

“Add a four-season Tulsi tips table, optional bird-listening notes and recordings, and a screen-time vs. outside-time tracker.”

Prize Categories

Best Use of Gemma

Petal & Leaf connects to the local gemma3:4b model through Ollama. Gemma does three jobs:

Plant photo checks: It suggests a likely plant, describes visible details, mentions visible issues, and gives a care tip based on the photo. This is an AI guess, not a diagnosis.
Daily quest planning: It creates three short, hands-on quests for my tulsi, using the soil state, the season, and where I am.
Friendly seasonal care: It rephrases the current seasonal tip from my table in a welcoming voice.

Photo checks are optional, and the app resizes photos before sending them to Ollama. The app does not identify birds. The bird quest only records a clip and a note.

Best Use of GitHub Copilot

I built Petal & Leaf by giving GitHub Copilot one prompt at a time and committing after each step. Copilot helped me with:

Building the React components and mobile-first styles
Writing the Ollama API integration and the JSON response handling
Adding the tabs layout, local-first logging, and fallback behavior
Fixing the soil-advice rules and the repeated quests
Writing the README and setup steps

Copilot was a development aid only. It is not needed to run the app, because the runtime AI features use the local Ollama model.

What's Next

Run Gemma inside the browser so it works on a phone with no laptop
A native Android version using on-device Gemma
Bird identification with BirdNET
A "walk quest" that sends you to the nearest park

What is SerpApi, and why I built LearnBeacon on it

Vrushali — Tue, 06 Oct 2026 13:50:00 +0000

🚀 How I Built LearnBeacon with SerpApi

Students often search across multiple websites for colleges, scholarships, careers and study resources.

I built LearnBeacon to bring this research into one place using SerpApi + an AI research agent.

🔎 What I learned:
• Live search data instead of outdated datasets
• One API for Web, Maps, News, YouTube, Jobs & more
• 30-minute caching to reduce API usage
• Source links for better trust
• Fallback data when the API is unavailable
• Not every query needs AI — a simple router decides when to use the agent

🎥 2-minute demo: https://youtu.be/Mkzj8lA4yRc
💻 GitHub: https://github.com/vrush1588/LearnBeacon
📝 What is SerpApi & why I built LearnBeacon: https://medium.com/@vrushalidev/what-is-serpapi-and-why-i-built-learnbeacon-on-it-e1b93bf9ecd4

If you're building an AI app that needs real-time web research, SerpApi is worth exploring.

SerpApi #AI #AIagents #BuildInPublic #WebDevelopment #Education #Hackathon

I Built a Voice-First AI Learning Companion That Doesn't Just Give Students Answers

Vrushali — Sat, 26 Sep 2026 09:36:20 +0000

What if an AI tutor didn't immediately give students the answer?

What if, instead, it encouraged them to think first, explain their reasoning, and discover the answer through conversation?

That question led me to build ThinkShiftAI — a voice-first AI learning companion for students, built for the Agora Voice AI Hackathon.

The core idea:

Ask → Think → Talk → Discover

not:

❌ Ask → Answer

🎯 Why I Built It

When a student gets stuck, the easiest thing for an AI to do is hand over the solution. But getting the answer isn't the same as understanding the concept.

Say a student points at a math problem and asks "can you help me solve this?" Instead of dumping the full solution, ThinkShiftAI nudges with questions like:

What do you already know?
Which part is confusing?
What would you try first?
Why do you think that approach works?

The goal isn't to make the student struggle — it's to create a small, useful pause between asking and receiving.

🎙️ Why Voice

Learning doesn't have to happen through typing. A student can just say "I don't understand this step" and keep going — no retyping, no re-reading a wall of text. It feels closer to talking with a tutor than querying a chatbot.

The voice layer runs on Agora Conversational AI; the app itself is Flutter.

🧩 How It Works

Student
   ↓ speaks a question
Voice AI (Agora RTC)
   ↓
AI understands the question
   ↓
ThinkShift reasoning
   ↓
Guiding question / explanation
   ↓
Student responds → conversation continues

Not Question → Answer. Instead:

Question → Understand → Guide → Student thinks → Student responds → Discover

🛠️ Tech Stack

Layer	Tech
Mobile	Flutter (Dart), Android
Voice	Agora RTC + Agora Conversational AI
STT	Deepgram `nova-3`
LLM	OpenAI `gpt-4o-mini`, prompted for the "one guiding question, never a quiz" rule
TTS	MiniMax `speech-2.8-turbo`
Backend	Python, Flask

Kept the architecture simple on purpose — simple enough to demo cleanly, but real enough to show how a modern voice-AI pipeline actually connects together.

🧠 The Interesting Problem: Don't Let the Tutor Become Annoying

If the AI keeps firing back "what do you think?" to every single message, the conversation turns frustrating fast. So the tutor has to balance:

Guidance ↔ Explanation

Sometimes the student needs a hint. Sometimes an example. Sometimes they just need the answer explained plainly. Getting that balance right — mostly through prompt design and keeping responses to 1–3 sentences with at most one guiding question — turned out to be one of the more interesting product problems, not a modeling problem.

👩‍🎓 A Sample Interaction

Student: "I don't know how to start this problem."

ThinkShift: "What information do you already have?"

Student: "We know the distance and time."

ThinkShift: "Great — if you know distance and time, which formula connects those two?"

The student is still doing the thinking. The AI acts like a learning companion, not an answer machine.

📷 Camera + Voice

The newest piece I've shipped: a student can point their phone at a handwritten problem, and ThinkShift talks about it — no typing, no switching screens.

Here's how it works under the hood:

Student snaps a photo of the problem.
A vision model (I went with Gemini's free tier here, since it handles image understanding well without needing a paid key) produces a short description of what's on the page — without solving it.
That description gets injected into the already-running voice session via Agora's think endpoint, so the same agent that's been talking to the student responds naturally, in the same voice, in the same conversation — no separate UI, no context switch.
The agent reacts the way it would to anything else the student says: one guiding question, not the answer.

The nice part is the architecture: instead of bolting on a separate "photo analysis" screen, the photo just becomes another turn in the same conversation. The student never leaves the voice experience — they show ThinkShift something, and it responds out loud, like they would to a person sitting next to them.

Next up on the roadmap: multilingual support (Hindi, Marathi), subject-specific tutoring modes, adaptive difficulty, and a simple student progress view.

🚀 What I Learned

Building this pushed me to think past "connect an LLM to a chat screen." A good AI product also has to reason about:

How the conversation should flow
When to explain vs. when to ask
How much guidance is the right amount
How voice changes the interaction entirely
How to keep it feeling natural, not scripted

The model is one part of the product. Interaction design is the other, bigger part.

🔗 Try It

🎥 Demo: Watch on YouTube

💻 GitHub: ThinkShiftAI-Voice-First-Conversational-Learning

Built for the Agora Voice AI Hackathon, powered by Agora Conversational AI.

I'd love to hear how you'd design a voice-first AI tutor — would you make it answer immediately, or make it guide the student first?

#AI #VoiceAI #Flutter #EdTech #ConversationalAI #Agora #GenerativeAI #Learning

Java Streams 101: The Beginner Cheat Sheet for Interviews ☕️

Vrushali — Tue, 22 Sep 2026 14:10:50 +0000

Java Streams confused you at first? 😵

You're not alone.

When you first see code like this:

numbers.stream()
       .filter(...)
       .map(...)
       .sorted(...)
       .collect(...);

it can feel like a lot of methods to remember.

But there is a simpler way to understand Streams:

Think of a Stream as a pipeline for processing data.

The data enters the pipeline, gets processed step by step, and produces a result.

Data
  ↓
stream()
  ↓
filter()
  ↓
map()
  ↓
sorted()
  ↓
collect()
  ↓
Result

Let's break down the most useful operations.

1. `filter()` → Keep what you need 🔍

filter() keeps elements that match a condition.

List<Integer> numbers = List.of(1, 2, 3, 4, 5);

List<Integer> evenNumbers = numbers.stream()
        .filter(n -> n % 2 == 0)
        .toList();

Result:

[2, 4]

Think:

filter = “Should this value stay?”

2. `map()` → Transform the values 🔄

map() changes each element into something else.

List<Integer> doubled = numbers.stream()
        .map(n -> n * 2)
        .toList();

Result:

[2, 4, 6, 8, 10]

Think:

map = “Change this value.”

3. `flatMap()` → Flatten nested data 📦

This one often confuses beginners.

Suppose you have:

List<List<Integer>> numbers = List.of(
        List.of(1, 2),
        List.of(3, 4)
);

Using flatMap():

List<Integer> result = numbers.stream()
        .flatMap(List::stream)
        .toList();

Result:

[1, 2, 3, 4]

Without flattening:

[[1, 2], [3, 4]]

After flattening:

[1, 2, 3, 4]

Think:

flatMap = “Take nested data and flatten it into one Stream.”

A simple mental picture:

[[1,2], [3,4]]
       ↓
   flatMap()
       ↓
 [1,2,3,4]

4. `sorted()` → Sort the data 🔢

Need the elements in order?

Use sorted().

List<Integer> sorted = numbers.stream()
        .sorted()
        .toList();

Result:

[1, 2, 3, 4, 5]

For descending order:

List<Integer> descending = numbers.stream()
        .sorted(Comparator.reverseOrder())
        .toList();

Think:

sorted = “Put the values in order.”

5. `collect()` → Gather the result 🧺

collect() is commonly used to gather Stream elements into a collection or another result structure.

For example:

List<Integer> result = numbers.stream()
        .filter(n -> n > 2)
        .collect(Collectors.toList());

Result:

[3, 4, 5]

In modern Java, you may also see:

List<Integer> result = numbers.stream()
        .filter(n -> n > 2)
        .toList();

Think:

collect = “Gather the processed values.”

6. `reduce()` → Combine into ONE result ➕

reduce() is different.

Instead of returning multiple processed elements, it combines them into a single result.

int sum = numbers.stream()
        .reduce(0, Integer::sum);

Result:

Visualize it:

1 → 2 → 3 → 4 → 5
        ↓
      reduce()
        ↓
       15

Think:

reduce = “Combine many values into one.”

The Cheat Sheet 📝

Operation	Simple meaning	Example
`filter()`	Keep what matches	`n -> n > 2`
`map()`	Transform values	`n -> n * 2`
`flatMap()`	Flatten nested data	Lists → one Stream
`sorted()`	Sort elements	ascending/descending
`collect()`	Gather the result	Stream → List
`reduce()`	Combine into one	sum, product, etc.

One Pipeline to Remember 🚀

Imagine you have:

List<Integer> numbers = List.of(5, 2, 8, 1, 4);

You want:

even numbers → double them → sort them → collect them

List<Integer> result = numbers.stream()
        .filter(n -> n % 2 == 0)
        .map(n -> n * 2)
        .sorted()
        .toList();

Step by step:

Original
[5, 2, 8, 1, 4]

      ↓ filter()

[2, 8, 4]

      ↓ map()

[4, 16, 8]

      ↓ sorted()

[4, 8, 16]

      ↓ toList()

[4, 8, 16]

That's the power of the Stream pipeline.

One More Interview Concept: Lambda vs Predicate 🤔

You might see:

.filter(n -> n > 10)

Here, you're passing a lambda expression.

filter() expects a Predicate, which is a functional interface representing a condition that returns true or false.

So:

Lambda
   ↓
n -> n > 10
   ↓
used as a Predicate
   ↓
filter()

You don't need to explicitly create a Predicate every time.

This is perfectly normal:

.filter(n -> n > 10)

The Mental Model 🧠

Don't memorize Streams as a collection of random methods.

Remember the pipeline:

FILTER
  ↓
Keep

MAP
  ↓
Transform

FLATMAP
  ↓
Flatten

SORTED
  ↓
Order

COLLECT
  ↓
Gather

REDUCE
  ↓
Combine

Or even simpler:

Filter → Transform → Organize → Collect OR Reduce

Once this mental model clicks, Java Streams become much less intimidating.

And when an interviewer asks:

“Can you explain Java Streams?”

you don't have to start by listing 20 methods.

Start with the idea:

A Stream provides a pipeline for processing elements from a data source using operations such as filtering, transforming, sorting, collecting, and reducing.

Then show a small example.

That's usually much easier to explain than trying to memorize definitions. ☕️

What Stream operation confused you the most when you first learned Java?

Java #JavaStreams #JavaInterview #JavaProgramming #LearnJava #Coding #Programming #Developer

Upgrade Your Skills with IBM SkillsBuild 🚀

Vrushali — Fri, 18 Sep 2026 14:35:20 +0000

Upgrade Your Skills with IBM SkillsBuild 🚀

If you're a developer or someone trying to grow your tech skills, finding good learning resources can sometimes be overwhelming.

I recently came across IBM SkillsBuild, a platform with free learning resources covering areas like:

💻 Programming
🤖 Artificial Intelligence
☁️ Cloud
🔐 Cybersecurity
📊 Data & Analytics
🧠 Emerging technologies

What I like is that you can explore topics based on your current level and learn at your own pace.

Whether you're a beginner starting your programming journey or a developer looking to explore a new area, it's worth checking out.

I'm always trying to learn something new and keep my skills updated, especially as technology and AI continue to change so quickly.

🔗 Explore IBM SkillsBuild:
https://skillsbuild.org/learning-catalog?q=programming

What are you currently learning or planning to learn next? 👇

IBM #SkillsBuild #Programming #AI #Learning #Developers #TechCommunity #100DaysOfCode

Did you know you can swap two variables in Dart without using a temporary variable?

Vrushali — Fri, 18 Sep 2026 07:41:43 +0000

🔄 Did you know you can swap two variables in Dart without using a temporary variable?

In many programming languages, we usually need a third variable to swap two values.

But Dart makes this really simple using multiple assignment:

var a = 10;
var b = 20;

(a, b) = (b, a);

print(a); // 20
print(b); // 10

✨ What’s happening here?

(b, a) creates the new values, and Dart assigns them back to (a, b) in the same statement.

So:

a = 10, b = 20

becomes:

a = 20, b = 10

No extra temporary variable needed. 🚀

A small Dart feature, but a nice trick to know when writing clean and concise code.

Dart #Flutter #Programming #CodingTips #LearnDart #SoftwareDevelopment

What if AI could understand India better?

Vrushali — Wed, 16 Sep 2026 10:25:05 +0000

🇮🇳 What if AI could understand India better?

Meet Sarvam AI — an Indian AI company building AI technologies with a strong focus on Indian languages, speech, and real-world use cases.

SarvamAI

From Marathi and Hindi to 20+ Indian languages, Sarvam is working on making AI more accessible across India's diverse linguistic landscape. 🤖🇮🇳

As a developer, I find this especially interesting because the future of AI isn't just about bigger models — it's also about:

🗣️ Understanding local languages & voices
🌐 Building for multilingual users
📱 Bringing AI into real-world applications
🇮🇳 Creating technology for India's unique needs

I'm excited to explore how Indian-language AI APIs and models can be used in Android and mobile applications.

AI that doesn't just work for India — but understands India. 🇮🇳

#SarvamAI #IndianAI #IndiaAI #AI #GenAI #Kotlin #Android #MobileDevelopment

DEV Community: Vrushali

Google Play is making DEX code optimization mandatory for eligible Android apps starting February 2027.

AndroidDevelopment #AndroidDev #GooglePlay #Kotlin #MobileDevelopment #R8 #AppOptimization

A2UI Looks Great, But Should Android Developers Use It Yet? 🤖

android #kotlin #ai #jetpackcompose

💻 My Claude Desktop folder quietly grew to 12 GB. I got 11.5 GB back!

Sloth Gist: drop in audio, video or text and get the gist, all on your own laptop

What I Built

Demo

Code

vrush1588 / sloth_gist

Local-first audio, video and text summarizer. Drop recordings, meetings or lectures and get a short summary, key points and to-dos, all on your own computer with open-weight models (Whisper + Ollama + Gemma). Nothing is uploaded.

Sloth Gist 🦥

Why open models?

Quick start

How I Built It

Why Open Innovation Matters Here

Where It Worked Better Than a Closed Approach

Honest Limits

What's Next

Stitch Desk is a local-first order assistant for boutiques and tailors.

What I Built

Demo

Code

vrush1588 / stitch-desk

A local-first order assistant for boutiques and tailors. Turn customer notes into editable order cards, organize contact details and measurements, draft WhatsApp messages, and find outfit design images for order references.

Stitch Desk

Features

Who it's for

How I Built It

What I learned about using a small model for money-related data

Why Does Open Innovation Matter?

My Agent Session

My First User

Honest Limits

Prize Categories

Best Use of Gemma

Best Use of SerpApi

Best Use of GitHub Copilot

What's Next

Petal & Leaf is a small web app that helps you look at your plants instead of your phone.

What I Built

Demo

Code

vrush1588 / petal_leaf

Screen-free nature quests powered by open-weight Gemma that runs in your browser, offline. 🌱

🌱 Petal & Leaf

App screenshots

Nature log

Gemma use cases

How I Built It

What went wrong (and what I changed)

Why Does Open Innovation Matter?

Honest Notes: What Worked and What Didn't

My Agent Session

Prize Categories

Best Use of Gemma

Best Use of GitHub Copilot

What's Next

What is SerpApi, and why I built LearnBeacon on it

SerpApi #AI #AIagents #BuildInPublic #WebDevelopment #Education #Hackathon

I Built a Voice-First AI Learning Companion That Doesn't Just Give Students Answers

🎯 Why I Built It

🎙️ Why Voice

🧩 How It Works

🛠️ Tech Stack

🧠 The Interesting Problem: Don't Let the Tutor Become Annoying

👩‍🎓 A Sample Interaction

📷 Camera + Voice

🚀 What I Learned

🔗 Try It

Java Streams 101: The Beginner Cheat Sheet for Interviews ☕️

1. filter() → Keep what you need 🔍

2. map() → Transform the values 🔄

3. flatMap() → Flatten nested data 📦

4. sorted() → Sort the data 🔢

5. collect() → Gather the result 🧺

6. reduce() → Combine into ONE result ➕

The Cheat Sheet 📝

One Pipeline to Remember 🚀

1. `filter()` → Keep what you need 🔍

2. `map()` → Transform the values 🔄

3. `flatMap()` → Flatten nested data 📦

4. `sorted()` → Sort the data 🔢

5. `collect()` → Gather the result 🧺

6. `reduce()` → Combine into ONE result ➕