DEV Community: Parth Verma

Lazy King: Do Less, Grow More

Parth Verma — Mon, 26 Oct 2026 16:19:39 +0000

👑 Lazy King: Do Less, Grow More 🌱

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

What I Built

Meet Lazy King — a playful mobile app that turns doing less into a game!

The idea is simple: what if your laziness could help you grow something? Instead of another productivity app constantly telling you to do more, Lazy King takes a humorous approach to everyday digital habits.

The app features:

🌱 A Growing Garden: Earn Lazy Points and watch your virtual plant evolve.
👑 Lazy Levels: Progress through levels as your points increase.
🎮 Interactive Actions: Simulate scrolling sessions, gaming, snoozing alarms, and relaxing.
🏆 Leaderboard: Explore a demo leaderboard featuring fictional players.
🔒 Privacy-Conscious Design: The current MVP uses simulated actions and demo statistics. It does not access your actual screen time, steps, or device activity.

The goal is to create a fun, lightweight experience that makes people smile while exploring an unconventional take on gamification.

Demo

Project status: Working MVP running locally on Android through Expo Go.

A public video demo or deployed web preview is not available yet.

Code

👨‍💻 GitHub: Lazy King Repository

The project is built with React Native and Expo, using JavaScript for the app logic and styles.

Replace the repository link above with your actual GitHub URL once your code has been pushed.

How I Built It

I built Lazy King using React Native, Expo, and JavaScript.

I started with a simple mobile interface and added interactive components, a point system, plant evolution stages, and navigation between the Garden, Leaderboard, and Rules screens.

The current architecture is intentionally lightweight:

Frontend: React Native
Development environment: Expo
State management: React's useState hook
Game mechanics: Client-side point calculations and simulated actions
Data: Illustrative statistics and fictional leaderboard entries

Getting the project running on my Android phone also involved troubleshooting Expo Go, dependency compatibility, and local development-server connectivity.

AI status: This version does not yet integrate an open-weight AI model. The current submission describes the working MVP, not an AI-powered feature that hasn't been implemented.

Why Does Open Innovation Matter?

Open innovation makes it easier for developers to experiment, learn from existing tools, and build projects without needing to create every component from scratch.

Tools such as React Native and Expo lower the barrier to building cross-platform mobile experiences. Their open-source ecosystems make it possible for individual developers and small teams to turn ideas into working prototypes.

For a project like Lazy King, this foundation leaves room for future experimentation with open-weight models and locally run AI features, without making the basic game dependent on a proprietary AI API.

My Agent Session

I used AI-assisted development to help plan the project, troubleshoot technical issues, and refine the implementation.

No DevRelay agent-session link is available for this submission yet.

The Lazy Payoff

Lazy King is still an early MVP, so I don't have measured user results or verified time savings to report.

Its current payoff is the ability to test a complete interactive game concept on a real Android device without first building a backend, account system, or device-tracking infrastructure.

The next step is to turn the prototype into a more persistent experience with saved progress and additional game mechanics.

What's Next?

Some ideas for future versions:

💾 Save player progress between sessions.
🌳 Add more plant evolution stages and unlockable items.
🌍 Build a real leaderboard with accounts and a backend.
🤖 Explore integrating an open-weight AI model for personalized, humorous game commentary or creative challenges.
🔐 Keep any future device integrations transparent, permission-based, and privacy-conscious.

Lazy King is a reminder that not every app needs to optimize every minute of your life.

Sometimes, you just need to let your little plant grow.

Do less. Grow more. 👑🌱

ClientReply AI: A Local-First AI Assistant for Freelancers

Parth Verma — Sun, 18 Oct 2026 13:50:46 +0000

ClientReply AI: A Local-First AI Assistant for Freelancers

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

What I Built

Freelancing isn't just about delivering great work. It's also about handling difficult client conversations.

How do you say no to extra work without damaging a relationship? How do you follow up on an overdue invoice without sounding rude? And how do you negotiate a budget without undervaluing your work?

I built ClientReply AI, a writing assistant that helps freelancers turn tricky client messages into clear, professional replies.

Users can paste a client's message, select a situation, choose a tone, and describe their goal. The application produces an editable draft, explains the communication strategy, and suggests a practical next step.

It supports eight scenarios:

Scope changes and additional work
Revision requests
Overdue payments
Price negotiations
Deadline changes
Professional boundaries
New project inquiries
General client communication

The intended users are freelancers, independent designers, developers, and small agencies who want to spend less time worrying about what to write and more time doing the work they are paid for.

Demo

🎥 Watch the ClientReply AI demo

Code

💻 View ClientReply AI on GitHub

The project uses FastAPI for the backend and HTML, CSS, and JavaScript for the frontend. It also includes optional Ollama integration and built-in fallback templates.

How I Built It

I built ClientReply AI using:

Python and FastAPI for the backend and API endpoints.
HTML, CSS, and JavaScript for the interactive interface.
Ollama for local inference with an open-weight language model.
Qwen 2.5 3B as the default model configuration.
Built-in fallback templates for common freelancer communication scenarios.

The workflow is straightforward:

The user pastes a client message and selects a scenario and tone.
The backend sends the prompt to the configured Ollama model.
The model returns structured output containing a subject, reply, rationale, and suggested next step.
The user edits the draft, copies it, or downloads it as a text file.

If Ollama is unavailable, the application falls back to predefined templates. These templates aren't AI-generated, but they allow the core interface to remain useful without a running model.

ClientReply AI drafts replies only. It doesn't automatically send messages to clients.

Why Does Open Innovation Matter?

For freelancers, affordability, privacy, and control matter.

A tool that relies entirely on a paid AI API introduces ongoing costs and makes the business dependent on another provider's pricing, availability, and policies.

Using an open-weight model through Ollama gives ClientReply AI another approach: run inference on your own machine and retain control over the model setup.

Here's why that matters:

Cost control: Local inference avoids per-request fees from a hosted model API, although hardware, electricity, and other operating costs still apply.
Privacy: When both the application backend and the model run locally, client messages can stay on the user's computer instead of being sent to an external AI provider.
Model flexibility: The default model can be replaced with another compatible model as requirements evolve.
Reduced dependence on external services: The application can still provide basic template-based replies when the model isn't available.

This is especially relevant to freelancers who handle sensitive project discussions but may not want to pay for another subscription just to draft client messages.

Open innovation makes it possible to experiment with a practical AI tool while retaining greater control over how it runs.

What Comes Next?

This is an MVP, and there's still plenty to improve.

My next priorities are to test the application with real freelancers, improve the quality of generated replies, and learn which scenarios provide the most value.

I'd also like to explore reusable writing preferences, freelancer-specific context, and additional ways to customize responses without compromising privacy.

The long-term goal is simple: help freelancers spend less time worrying about what to write and more time doing the work they are paid for.

I'd love to hear your feedback: What client conversation do you find hardest to handle as a freelancer?

What If We Used AI to Spend Less Time on Screens?

Parth Verma — Fri, 09 Oct 2026 14:14:15 +0000

TouchGrass AI — Get out. AI stays in.

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

What I Built

I built TouchGrass AI, a local-first AI outdoor companion that encourages people to spend less time on their screens and more time exploring the real world.

The idea behind the project is simple:

AI creates the experience, but the experience exists to get you away from AI.

Users can choose an outdoor activity, such as running, walking, hiking, or cycling, select a duration, and describe their goal. The AI then generates a personalized outdoor mission with a warm-up, main activity, outdoor challenge, cool-down, and motivation.

But generating a mission is only the beginning.

TouchGrass AI includes a Go Outside Mode with a timer so users can put their phones away and focus on their activity. When they return, they can reflect on their energy, mood, and difficulty, then save their experience to My Journey.

The app keeps experience history in the browser using local storage.

I designed it for students, developers, remote workers, and anyone who wants a little encouragement to step outside.

My goal wasn't to build another AI chatbot that keeps people engaged with a screen. I wanted to build something that gives people a reason to leave it.

Demo

Watch the project demo:

Touchgrass_AI.mp4 - Google Drive

drive.google.com

Code

GitHub repository: https://github.com/parthverma2005/Touchgrass_AI.git

TouchGrass AI is open source under the MIT License. The repository includes the frontend, FastAPI backend, setup instructions, and local AI integration.

How I Built It

I built TouchGrass AI using a lightweight web stack and an open-weight language model running locally.

Tech stack

AI model: Qwen 2.5 0.5B
Local inference: Ollama
Backend: Python and FastAPI
Frontend: HTML, CSS, and JavaScript
Experience history: Browser localStorage

How it works

The user chooses an activity, duration, and goal.
The frontend sends the request to the FastAPI backend.
The backend sends a prompt to Qwen 2.5 0.5B through Ollama.
The generated mission is displayed in the frontend.
The user starts Go Outside Mode and completes the activity.
Afterward, the user records a reflection, which is saved locally in the browser.

I chose a small model because I wanted to experiment with local AI without requiring a powerful machine or a paid AI API.

The application does not require a cloud AI API for its core mission-generation feature. The model must be installed locally first, and the backend must be running for mission generation to work.

I also added a Local AI information panel to make the model and inference approach visible to users.

Why Does Open Innovation Matter?

Open innovation made this project possible in a way that fits its purpose.

Privacy by design

Mission generation can happen locally instead of sending each request to a cloud AI provider. The user's saved reflections also remain in their browser rather than requiring a remote database.

Accessibility and cost

Using a small open-weight model means developers can experiment with AI-powered applications without paying per-request API fees.

Freedom to experiment

Local inference gives developers the freedom to inspect the setup, modify prompts, and experiment with other compatible models. It also makes the project easier for others to learn from and extend.

AI that encourages disconnection

One of the interesting contradictions of modern technology is that AI can be used to encourage people to spend less time using technology.

That became the guiding principle for this project:

Use AI briefly. Go outside. Experience the world. Return only when you need to.

Open AI gives me the ability to build a tool where AI supports the experience instead of becoming the experience itself.

My Agent Session

I used AI-assisted development to help design and implement the project, connect FastAPI to Ollama, integrate the local model, and refine the mission-generation prompts.

I also worked through the frontend integration, outdoor timer, reflection form, and local journey history.

Final Thought

AI is becoming increasingly good at keeping us on our screens.

I wanted to experiment with using it for the opposite purpose.

TouchGrass AI gives you a mission, starts the clock, and encourages you to experience something beyond the screen.

Get out. AI stays in.