DEV Community: Anshul Chikhale

SlothSort

Anshul Chikhale — Tue, 20 Oct 2026 05:05:40 +0000

SlothSort: Let Your Files Sort Themselves

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

What I Built

SlothSort is a calm, local-first file tidier for the Downloads folder you keep avoiding.

It proposes sensible destinations, better filenames, and possible duplicate warnings for messy files. Instead of spending an afternoon sorting screenshots, PDFs, documents, voice notes, and receipts, you review one simple plan.

SlothSort is designed around a very lazy workflow:

Add files.
Let the local sorter make a plan.
Review the suggestions.
Approve the tidy-up.

Nothing is silently deleted. Files marked as possible duplicates are flagged for review instead of being removed automatically.

The people who get to be lazier are freelancers, students, researchers, and anyone with a Downloads folder that has become a second desktop.

Demo

Live demo: SlothSort

Try this flow:

Open the demo.
Review the sample files in the queue.
Click Tidy all.
See the proposed destinations and duplicate warnings.
Click Add files to add local file metadata to the review queue.
Click Why local? to see the privacy explanation.

Code

Public repository: github.com/anshulchikhale30-p/wildquest

SlothSort lives in the public/slothsort/ directory.

How I Built It

SlothSort is a lightweight static web app with a small Node.js server. The interface is designed to feel calm instead of urgent, with a slow-and-steady workflow, transparent actions, and no destructive automation.

The project is built around a local AI architecture. A production version can send file metadata and a bounded sorting prompt to an Ollama-compatible endpoint running an open-weight model such as Qwen2.5 3B Instruct or Llama 3.2 3B.

The local model can suggest:

A destination folder
A cleaner filename
Whether a file looks like a duplicate
Whether an item needs human review

The demo includes a deterministic local fallback so the experience works without internet access. It uses transparent rules to classify common file types and create proposed destinations.

The important product decision is that SlothSort creates a plan before taking action. It does not silently delete files or move anything without approval.

Why Does Open Innovation Matter?

File organization often involves personal documents, work files, screenshots, receipts, and private media. Sending that entire folder to a hosted AI API is convenient, but it creates privacy concerns and a recurring cost.

Open and local AI makes a better version of this small tool possible:

Files can be organized on a laptop without an internet connection.
Personal file metadata does not need to leave the device.
Users can swap Qwen, Llama, or another compatible open-weight model.
The sorting prompt and decision rules remain inspectable.
There is no per-file API bill.
The user can change the agent’s behavior instead of accepting a black-box automation.

A closed API might make the first prototype faster, but the local approach is better for a personal file tool because the files are private, the task is repetitive, and the automation should be cheap enough to run whenever needed.

My Agent Session

I did not include a DevRelay embed. The implementation is available in the public repository.

The Lazy Payoff

The demo estimates approximately two minutes of manual effort saved per file, depending on how messy the folder is.

For an inbox of eight files, that is roughly 18 minutes of avoided sorting work. More importantly, SlothSort removes the hardest part: deciding where to begin.

I have not yet measured this with a paying user. The first people I would test it with are freelancers and students who regularly postpone organizing their Downloads folder because the task feels too small to schedule and too annoying to start.

ReceiptDesk: A Private AI Expense Inbox for Freelancers

Anshul Chikhale — Sat, 17 Oct 2026 14:25:10 +0000

ReceiptDesk: Private AI Receipt Sorting for Freelancers

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

What I Built

ReceiptDesk is a private, local-first receipt inbox for freelancers.

Freelancers do not usually have an accounting department. They have a folder of screenshots, a handful of emailed receipts, and a monthly reminder that taxes are coming.

ReceiptDesk turns receipt text into clean expense rows with a merchant, date, category, tax, and total.

The simple business is a lightweight subscription for solo freelancers who want an accountant-ready expense inbox without uploading every purchase to a third-party AI service. The product could charge for multiple workspaces, saved exports, and setup help while keeping the core local-first workflow available.

Demo

Live demo: ReceiptDesk

Try this flow:

Click Load demo receipts.
Filter the inbox by Software, Meals, or Travel.
Click Add receipt and paste receipt text.
Export the rows as a CSV file.
Try it with the network disabled: the local parser still works.

Code

Public repository: github.com/anshulchikhale30-p/wildquest

ReceiptDesk lives in the public/receiptdesk/ directory in the repository.

How I Built It

ReceiptDesk is a small static web app with a lightweight Node.js server. It stores the demo and user-added expense rows in browser local storage, so there is no account and no hosted database in the core flow.

The open/local AI path uses an Ollama-compatible endpoint when available. The app sends a bounded extraction prompt to an open-weight model such as Qwen2.5 3B Instruct or Llama 3.2 3B, asking for the merchant, date, category, tax, and total as JSON.

When no local model is reachable, ReceiptDesk uses a deterministic browser-side parser. It recognizes common total and tax labels and applies transparent category heuristics.

That fallback makes the demo inexpensive, private, and usable without internet access.

Why Does Open Innovation Matter?

Receipt data is sensitive. It can reveal where a freelancer works, who they meet, what tools they use, and how much they spend.

A closed hosted API would make the first prototype easy, but it would also turn every receipt into an upload and every extraction into a recurring inference cost.

The open/local approach makes a small side-hustle product more realistic:

A freelancer can process receipts on a laptop with no internet.
Receipts stay on the device unless the user deliberately connects a local model.
The model can be swapped as better open-weight options become available.
The extraction prompt and fallback behavior are inspectable and editable.
There is no per-receipt API bill forcing the business into a high-volume pricing model.

Open AI is useful here not because it makes a more impressive demo, but because it changes the economics and privacy model of a tiny product someone could actually pay for.

My Agent Session

I did not include a DevRelay embed. The implementation is available in the public repository.

My First User

I have not landed a paying user yet.

The first validation target is a solo freelancer who currently collects receipts in a phone folder and sends them to an accountant once a quarter.

The first question I would test is whether local privacy and one-click CSV export are valuable enough to pay for every month.

ReceiptDesk: A Private AI Expense Inbox for Freelancers

Anshul Chikhale — Sat, 17 Oct 2026 14:16:21 +0000

ReceiptDesk: Private AI Receipt Sorting for Freelancers

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

What I Built

ReceiptDesk is a private, local-first receipt inbox for freelancers.

Freelancers do not usually have an accounting department. They have a folder of screenshots, a handful of emailed receipts, and a monthly reminder that taxes are coming.

ReceiptDesk turns receipt text into clean expense rows with a merchant, date, category, tax, and total.

Demo

Live demo: ReceiptDesk

Try this flow:

Click Load demo receipts.
Filter the inbox by Software, Meals, or Travel.
Click Add receipt and paste receipt text.
Export the rows as a CSV file.
Try it with the network disabled: the local parser still works.

Code

Public repository: github.com/anshulchikhale30-p/wildquest

ReceiptDesk lives in the public/receiptdesk/ directory in the repository.

How I Built It

When no local model is reachable, ReceiptDesk uses a deterministic browser-side parser. It recognizes common total and tax labels and applies transparent category heuristics.

That fallback makes the demo inexpensive, private, and usable without internet access.

Why Does Open Innovation Matter?

Receipt data is sensitive. It can reveal where a freelancer works, who they meet, what tools they use, and how much they spend.

A closed hosted API would make the first prototype easy, but it would also turn every receipt into an upload and every extraction into a recurring inference cost.

The open/local approach makes a small side-hustle product more realistic:

A freelancer can process receipts on a laptop with no internet.
Receipts stay on the device unless the user deliberately connects a local model.
The model can be swapped as better open-weight options become available.
The extraction prompt and fallback behavior are inspectable and editable.
There is no per-receipt API bill forcing the business into a high-volume pricing model.

Open AI is useful here not because it makes a more impressive demo, but because it changes the economics and privacy model of a tiny product someone could actually pay for.

My Agent Session

I did not include a DevRelay embed. The implementation is available in the public repository.

My First User

I have not landed a paying user yet.

The first validation target is a solo freelancer who currently collects receipts in a phone folder and sends them to an accountant once a quarter.

The first question I would test is whether local privacy and one-click CSV export are valuable enough to pay for every month.

WildQuest: Open-Source AI That Gets You Outside 🌿

Anshul Chikhale — Sat, 10 Oct 2026 05:03:11 +0000

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

What I Built

What if AI didn't try to keep you on your screen, but actually encouraged you to put your phone away?

Meet WildQuest 🌿 — an offline-first AI field guide that turns a little free time into a small outdoor adventure.

Choose your available time, location, energy level, and who you're with. WildQuest creates five gentle outdoor prompts:

👀 Notice — Pay attention to something around you.
👂 Listen — Discover the sounds you usually ignore.
🚶 Move — Explore your surroundings.
🍃 Collect — Find something interesting to remember.
✍️ Reflect — Turn your experience into a personal field note.

Trail Mode guides you through one task at a time, with a countdown and progress bar. No endless feeds, distracting notifications, or pressure to stay engaged.

The idea is simple: start a mission, put your phone away, explore the real world, and return to record what you discovered.

WildQuest is designed for solo walks, families, neighborhood explorers, and anyone who needs a gentle push to spend more time outdoors.

Demo

🌐 Live Demo: https://wildquest-4ltpnmcp.manus.space

Try it yourself:

Choose your available time and place.
Generate an outdoor field mission.
Enter Trail Mode and complete the five prompts.
Write a reflection and generate your field note.
Disconnect your internet and try generating a mission again to experience the offline fallback.

Code

💻 GitHub Repository: https://github.com/anshulchikhale30-p/wildquest

The repository contains the app, local development server, README, route manifest, and build configuration.

Contributions and ideas are welcome!

How I Built It

WildQuest is a static, mobile-first web application powered by a lightweight Node.js server.

I designed the interface to feel like a field notebook rather than another productivity dashboard, using warm paper tones, ink-green panels, landscape-inspired visuals, and short, calming prompts.

The AI architecture is designed to be open and replaceable:

Open-weight AI: The app can connect to a local Ollama-compatible endpoint and use models such as Qwen2.5 3B Instruct or Llama 3.2 3B for mission generation.
Offline-first fallback: When the local model endpoint is unavailable or the device is offline, a deterministic, seeded local generator keeps the core experience working.
Local field notes: Reflectionss and related data stay in the browser by default.
No account required: The app is designed without a hosted database or location tracking.

One important design decision was making offline support part of the experience rather than treating it as an error. An outdoor tool should still be useful when the network disappears.

Why Does Open Innovation Matter?

WildQuest explores a different use of AI: helping people spend less time interacting with technology.

Open innovation makes that possible in several ways:

Privacy: Personal reflections don't need to be uploaded to a third-party server.
Freedom of model choice: Developers can experiment with Qwen, Llama, or other compatible open-weight models.
Offline resilience: A local model and deterministic fallback reduce dependence on internet connectivity.
Transparency: The mission-generation prompt and implementation can be inspected and adapted.
Accessibility: The local fallback makes the core experience usable without a paid inference account.

A closed API could generate outdoor prompts, too. But an open, replaceable architecture gives developers more control over privacy, costs, model selection, and how the AI behaves.

The goal isn't to build an AI that keeps talking.

The goal is to build an AI that gives you a reason to close the app and notice the world around you. 🌎

My Agent Session

I haven't included a DevRelay session embed in this submission. The complete implementation and build history are available in the public GitHub repository.

Prize Categories

WildQuest is submitted to the Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass.

The 9:15 PM Question That Inspired CareBridge

Anshul Chikhale — Sun, 04 Oct 2026 08:34:14 +0000

CareBridge: The Family Care Handoff Nobody Should Have to Carry Alone

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

At 9:15 PM, Leela asked one simple question

“Who is taking me to the hospital tomorrow?”

Nobody answered immediately.

Not because her family did not care.

Her grandson thought her daughter had arranged the ride. Her daughter believed her husband was handling it. Her husband had saved the appointment time somewhere—but could not remember where.

The prescription folder was still on the table. The doctor had asked Leela to bring it. Someone had promised to remind her about her tablets. Nobody knew who.

Leela asked again.

That moment stayed with me.

Because this is how family care often becomes difficult. Not through one dramatic failure, but through dozens of small details scattered across voice notes, phone calls, paper reminders, and busy family chats.

There is usually one person who remembers everything.

They remember the appointment.

They know where the documents are.

They remind everyone about the ride.

They follow up when nobody responds.

They quietly become the family’s memory.

I wanted to build something for that person.

That became CareBridge.

The problem is not that families do not care

The problem is that care is distributed, but information is fragmented.

Imagine Leela, a grandmother with a hospital visit on Thursday morning. She sends a natural voice message:

“The doctor said Thursday morning. I’m worried about getting there. Someone needs to bring my prescription folder, and please remind me about my tablets.”

That single message contains:

An appointment
A transportation need
A worried emotion
A prescription document
A medication reminder
A request for follow-up

But it does not arrive as a clean task list.

It arrives as a human message.

By Wednesday evening, the family starts asking:

What time is the appointment?
Who is taking Leela?
Where is the prescription folder?
Did anyone remind her about the tablets?

Nobody is careless.

Everyone is busy.

That is exactly why the problem matters.

Family care is a chain of small promises. One person drives. One person brings the documents. One person confirms the appointment. One person calls afterward.

When those promises remain invisible, one family member quietly carries them all.

What I built

CareBridge is a voice-first family-care coordination workspace for the moment when love becomes logistics.

It helps a family turn one natural voice or text update into a reviewable care handoff:

A family member speaks or types an update.
CareBridge keeps the relationship and emotional context.
AI extracts possible appointments, responsibilities, reminders, and follow-ups.
A person reviews and edits the draft.
Only approved details become shared family actions.
The approved handoff can be read aloud.

The most important rule in CareBridge is:

AI suggests. A human approves.

CareBridge does not diagnose.

It does not prescribe.

It does not replace a doctor or a family member.

It organizes coordination and keeps uncertain information in draft form until a person confirms it.

The moment the story changes

In CareBridge, we open Handoff Studio.

We select:

Person: Grandma
Emotion: Worried

Then we enter Leela’s update.

The system does not pretend that the message is already perfect. It treats the update as raw human context that needs to be organized carefully.

CareBridge identifies possible actions:

Review the Thursday appointment
Confirm transportation
Bring the prescription folder
Remind Leela about her tablets
Call after the hospital visit

But these actions are not silently added to the family plan.

They appear as a draft.

A family member can review them, edit them, remove anything incorrect, and approve only what is actually true.

That is the difference between an assistant that takes control and a tool that supports a family.

After approval, the handoff becomes visible:

Who owns each responsibility
What needs to happen next
What is still pending
What has already been completed
Whether one person is carrying too much

The family no longer has to ask, “Who is handling this?”

They can see it.

The family tree

CareBridge begins with a growing family-care tree.

Dad. Mom. Grandpa. Grandma. Sister. Brother. Friend. Wife.

Each person can have a relationship, responsibility, and emotional context.

The tree is more than decoration. It represents an important idea:

Care becomes lighter when it is shared.

The product also includes:

Family roles and responsibilities
Care-load visibility
Private family memories
Older-adult mode
Larger text
High contrast
Voice capture
Voice playback
Multilingual context
Local export
Privacy-oriented workspace controls

The goal is not to create another dashboard full of cards.

The goal is to help a real family understand, decide, and follow through.

Demo

Try the live CareBridge application

The main demo path is:

Open Handoff Studio.
Select a family member and emotion.
Type an update, speak an update, or upload a recording.
Review the extracted actions.
Approve only the correct details.
Share the verified handoff.
Play the approved care update aloud.

The starter workspace uses synthetic family records so anyone can explore the product immediately without login. The workflow is real, but the project does not claim clinical validation.

How the technology supports the story

Family voice or text update
            │
            ▼
CareBridge web service on Render
            │
            ├── ElevenLabs Speech to Text
            │
            ▼
Reviewable extraction draft
            │
            ▼
Human approval
            │
            ├── Shared care action
            ├── Appointment or reminder
            ├── Multilingual confirmation
            └── ElevenLabs spoken handoff

Separate Render AI runtime
            │
            └── Open-weight model + safe fallback

ElevenLabs: giving the family a voice

We all know that a product feels different when it can listen and speak naturally.

ElevenLabs is one of the tools developers reach for when they want to build lifelike voice experiences without creating an entire speech platform from scratch.

In CareBridge, ElevenLabs is used at two important moments.

Speech to Text

A family member can speak naturally instead of rewriting a voice note into formal text.

Text to Speech

After approval, the verified handoff can be read aloud for the person receiving care or for family members who prefer listening.

This makes voice more than a technical feature.

It becomes an accessibility layer.

Care does not always happen at a keyboard. Older adults may be more comfortable speaking and listening than navigating a dense interface.

The API key is stored securely on the server through ELEVENLABS_API_KEY. It is not placed in the frontend or committed to GitHub.

Render: turning the idea into a real product

We all know the difference between a project that works only on a laptop and a product that someone else can actually open and use.

For deployment, Render is one of the developer-favourite platforms for taking an application from GitHub to a public URL without unnecessary friction.

With Render, CareBridge can run as a real web application:

carebridge-web serves the interface and protected server routes.
carebridge-ai-runtime runs the separate FastAPI extraction service.
Environment variables and secrets stay on the server.
The deployment is described through a checked-in render.yaml Blueprint.

Render gives CareBridge a clear boundary:

Family browser
      ↓
CareBridge web service on Render
      ↓
Secure server-side voice route
      ↓
ElevenLabs Speech to Text
      ↓
Reviewable care draft
      ↓
Human approval
      ↓
Shared family care plan

The browser never needs to know the provider secret.

The web service handles the product workflow.

The AI runtime has one bounded responsibility: organize coordination details into a draft.

The family remains in control.

Open-weight AI: useful, bounded, and replaceable

The repository includes a Render-ready open-weight extraction runtime.

The model is configurable through MODEL_ID. The current default is:

HuggingFaceTB/SmolLM2-360M-Instruct

The runtime is prompted to extract coordination details such as:

Appointments
Transportation
Reminders
Tasks
Follow-ups

It is explicitly not a medical diagnosis system.

If the model is unavailable or returns an unusable result, CareBridge uses a predictable deterministic fallback. Every response remains marked as requiring human review.

Why open innovation matters

Family-care information is personal.

I would not want an opaque assistant to silently rewrite an uncertain voice note into something that looks like a medical instruction.

Open innovation makes the important boundaries visible and replaceable:

The extraction prompt can be inspected.
The model can be swapped.
The deterministic fallback is included in the repository.
Human review is enforced in the workflow.
The family can see what the system suggested.
A future organization can self-host or choose another model.
Privacy, language, cost, and hardware requirements can influence the deployment.

CareBridge does not need an assistant that answers everything.

It needs a careful system that says:

“Here are the possible next steps. Please confirm what is actually true.”

What I learned

The hardest part was not extracting more information.

It was deciding what the system must not do.

A family-care assistant should not silently turn an uncertain voice note into an assigned task.

It should preserve the person’s emotion and context. It should suggest structure. It should show the draft. Then it should ask a person to confirm.

The most important product decision in CareBridge is not the AI extraction.

It is the review boundary around it.

Prize Categories

Best Use of Render

CareBridge uses Render as part of the actual product architecture, not only as static hosting.

Render runs the web application and the separate open-weight AI extraction runtime. The deployment is reproducible through the checked-in Render Blueprint, while provider secrets remain protected inside the server environment.

Render helped turn CareBridge from a local project into a real, shareable web application.

Best Use of ElevenLabs

ElevenLabs powers both sides of the voice handoff:

Natural family updates become editable text through Speech to Text.
Approved care actions can be spoken back through Text to Speech.

Voice is not decoration in CareBridge.

It helps family members who should not have to type, navigate a complicated interface, or translate a formal care summary themselves.

Code

GitHub repository: anshulchikhale30-p/carebridge-family-care

The repository includes:

React application
Server routes
Render Blueprint
Open-weight AI runtime
ElevenLabs voice integration
Human-review workflow
Safety boundaries
Automated tests

My Agent Session

I am not adding an agent-session link because I do not have a public DevRelay session URL to share in this post.

Final thought

At 9:15 PM, Leela asked:

“Who is taking me tomorrow?”

That question should not have to travel through four different chats before somebody answers it.

CareBridge is my attempt to make remembering, updating, and following through a little less lonely.

Because the best care system is not the one that sounds the smartest.

It is the one that helps a family say:

“We know what needs to happen—and we know who is beside you.”

Family care, shared. AI suggests. Families decide.