DEV Community: Diya Vijay

I Built an AI That Wants You to Stop Using It 🌱

Diya Vijay — Sat, 10 Oct 2026 12:53:25 +0000

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

What I Built

GrassQuest — an AI app that wants you to stop using it.

Most AI apps try to keep you on your screen.

GrassQuest does the opposite.

It is an offline AI-powered nature scavenger hunt. The app gives you a real-world challenge like:

🍃 Find a leaf.

You go outside, find one, take a photo, and GrassQuest uses a local open-weight vision model to check whether you've completed the challenge.

If you succeed:

🎉 Challenge Complete!
+10 XP

📱 Now put your phone away.

The idea is simple: AI should sometimes help you leave the screen, not spend more time on it.

It's designed for anyone who wants a small excuse to step outside — especially people who spend most of their day working or studying in front of a screen.

The game includes XP, levels, streaks, milestones, and different challenges to make going outside feel a little more fun.

Demo

GrassQuest works in one simple loop:

Get a challenge → Go outside → Find it → Take a photo → Local AI verifies it → Earn XP → Put your phone away.

In the demo, I complete a real challenge by finding a leaf and having the local vision model verify it.

The AI runs locally using SmolVLM2 + MLX, so the core image analysis doesn't depend on a cloud vision API. I also tested the local version with the internet disconnected after the model was downloaded.

The best part of the demo is what happens after the AI does its job:

“Challenge Complete 🎉 Now put your phone away.”

I also tested the application with the internet disconnected after the AI model had been downloaded.

Code

💻 GitHub: https://github.com/DiyaVj/grass-quest

The project is intentionally small and easy to run locally. There is no database, no user account, and no cloud AI API involved in the core experience.

How I Built It

GrassQuest uses SmolVLM2-2.2B-Instruct, an open-weight vision-language model, running locally through MLX and mlx-vlm.

The architecture is:

                 GrassQuest
                     │
                     ▼
              Next.js PWA
                     │
              Take a photo
                     │
                     ▼
             Local FastAPI API
                     │
                     ▼
          SmolVLM2-2.2B-Instruct
                + MLX
                     │
              Visual perception
                     │
                     ▼
          Deterministic Python
              validation
                     │
                     ▼
             Challenge result
                     │
                     ▼
             XP / Milestone
                     │
                     ▼
             📱 Put it away

The important part is that the AI is not just an optional feature added on top of the application.

It is the mechanism that makes the scavenger hunt work.

A problem I ran into

My first implementation asked the vision model something like:

"Does this image satisfy the challenge?"

That sounded reasonable.

It wasn't.

The model could see the image correctly but still hallucinate that the required object was present because the challenge itself was influencing its answer.

For example, an image containing a person could be incorrectly judged as containing a rock when the challenge was "Find a rock."

So I changed the architecture.

Instead of asking the model to make the final decision:

VLM → "Yes/No, did they complete the challenge?"

I now use:

VLM → "What target object is visibly present, and how many can you see?"

Then deterministic Python code makes the final decision.

For example:

Challenge:
Find two leaves.

AI perception:
leaf → count: 1

Python validation:
1 >= 2 → false

Result:
Challenge failed

This separation makes the system much more reliable and gives the AI a clearly defined role: visual perception, not business logic.

Why Does Open Innovation Matter?

I could have built this using a closed vision API.

But that would miss an important part of the idea.

GrassQuest is specifically designed around local AI.

Once the model has been downloaded, the image analysis can happen without sending the user's photos to a third-party AI service.

That gives the project several advantages:

🔒 Privacy — photos don't need to leave the local environment for AI analysis.
📡 Offline capability — the core AI inference doesn't depend on an internet connection.
💰 No per-image API cost — there is no cloud inference bill for every challenge.
🧩 Model freedom — the open-weight model can be replaced, optimized, or experimented with.
🔍 Transparency and control — I can inspect and change how the AI is used rather than treating a closed API as a black box.

For this particular project, open AI also makes the product concept stronger.

The whole point is to disconnect from the screen.

It felt contradictory to build an app encouraging people to go outside while requiring a constant connection to a cloud AI service.

Local inference makes that contradiction much smaller.

The idea behind GrassQuest

The easiest way to describe GrassQuest is:

What if the best AI app was one you were supposed to stop using?

AI is becoming very good at helping us do more things on our screens.

I wanted to build something that used AI for the opposite purpose.

Go outside. Find something real. Take one photo. Let AI verify it. Then put the phone away.

That's GrassQuest.

How Can Power Virtual Agents Transform Your Customer Engagement?

Diya Vijay — Fri, 03 Nov 2023 15:48:46 +0000

Are you a student with a groundbreaking startup idea or an entrepreneur aiming to elevate your business to new heights? In today's fast-paced digital landscape, effective customer engagement is the key to success. But how can you stay ahead in this ever-evolving world of innovation?

Introducing Power Virtual Agents (PVA) – a true game-changer in the realm of conversational AI (Artificial Intelligence). Whether you're a student start-up with a vision or a seasoned entrepreneur seeking to revolutionize your project, this is an opportunity you won't want to miss.

With PVA, you'll embark on an exciting journey into the world of conversational AI, where the possibilities are limitless. Discover how this revolutionary technology can help you engage your customers more effectively, drive growth, and take your business to the next level.

Ready to explore the future of customer engagement? Click the link below to dive into our article and empower your business with the magic of Power Virtual Agents: Read Now 🌟

Introduction to Stack

Diya Vijay — Tue, 08 Feb 2022 13:49:00 +0000

Stack is a linear data structure in which data can be added or removed only at one end. This end is generally known as "TOP" of the stack.
let's take one example for better understanding. It is like stack of plates in cafe, where every new plate is added to the top of the stack and removed from the top as well. This simply means that the last plate added to a stack is the first plate to be removed. Hence stacks are also called Last in First Out (LIFO)structure.
Let's take another example. Look in this picture, it looks yummy right? haha....it's a stack of oreo. Now if you want to build the Eiffel Tower then you have to add another Oreo on top of this Oreo stack. And now imagine you want to eat an Oreo (read the second word after "and" again, just imagine or buy your own Oreo cause obviously I won't share it with you, LOL) then you have to take it from the top of the Oreo stack.

Now let's talk about implementation of stack. well, stack can be implemented in two ways.
1) Static implementation
2) Dynamic implementation

Static implementation : static implementation uses array to creat stack.
Dynamic implementation : It uses linked list that uses pointers to implement the stack.

# Terminology of Stack

PUSH: when an item is added or inserted in a stack, the operation is known as push.
POP: when an item is removed or deleted from a stack, the operation is known as pop.
TOP: this term refers to the top of stack. top is used to check stack's overflow or underflow condition. top is initialized by -1.
if TOP = -1 // indicates the stack is empty if TOP = MAXSIZE-1 // indicates the stack is full

Docket – A CLI application

Diya Vijay — Sun, 30 Jan 2022 10:51:33 +0000

Let's build a docket cli application. A docket is just a list of tasks that must be done. It functions similarly to a to-do application in that you may add tasks, browse a list of tasks, and mark them as completed once they are completed.
You must first install Python on your machine. Python is generally installed by default on most current systems. Open a terminal and type the following command to see which version of Python is installed on your machine.

python3 –version

It will give you information about the Python version that is currently installed. You can also install Python by visiting this website: https://installpython3.com/.
To begin, make an empty folder in which to save our project's files.
Now, open your favorite code editor and begin developing our program. Open the empty folder we made for our project. Now, activate the Python environment; if you have Python 3.4 or higher, execute the following command.

$ python -m venv [directory]

Bingo! Our Python environment is now active. Now, let's create our python file and name it "'docket.py"', but it's not required to use the same name; you're smart, and I know you can come up with a better one.
Before we begin coding in our Python file, we must first generate four other files. Wait! I know you're excited, but let me explain you what kind of files we'll be making and why. So, we'll need to make two text files: one for entering our tasks (task.txt) and another for keeping completed tasks (completed.txt). Let us now discuss the last two files. We must write one “.bat” (docket.bat) file (which will allow us to run the software on Windows) and one “.sh” (docket.sh) file (helps us to run the program on Linux). However, you must include the following code in these files.

docket.bat

@echo off

Python3 docket.py %1 %2 %3

docket.sh

#!/usr/bin/env bash

Python3 docket.py “$@”

Finally! Now take off!!!! for our python file, which will be used to code our fantastic program. For constructing our application's CLI interface, we will use Python's argparse module. The argparse module simplifies the creation of user-friendly command line interfaces. The argparse module also generates help and usage messages automatically and generates errors when users provide invalid arguments to the program. You may install argparse on your terminal by typing "' pip install argparse"'.

Import argparse and use the code below to open our txt files.

import argparse

task = open("task.txt","r+")
completed_task = open("completed.txt", "r+")

Create some variables to read lines from and the length of our txt files.

task_data = task.readlines()
completed_data = completed_task.readlines()
c=len(completed_data)
t= len(task_data)

Let's begin our argparse module now.

parser= argparse.ArgumentParser()

We need to add arguments to the CLI in order to accept user input. We basically need two arguments. One is input1 for writing instructions, and the other is input2 for writing assignments. This is how you use argparse to declare variables and take input from the cli.

parser.add_argument('input1',
action='store', type=str, nargs='?', default='default')

parser.add_argument('input2', action = 'store',
                    nargs='?',
                    default='-1')

args = parser.parse_args()

Let's get started on the conditions for our commands now. First, we specify whether we want to use the default mode or enter the command "'./docket help"', which will display the application's usage.

if(args.input1 == 'default' or args.input1 == 'help'):
    print('''Usage :-
$ ./docket add "hello world"    # Add a new item with priority 2 and text "hello world" to the list
$ ./docket ls                   # Show incomplete list items
$ ./docket del INDEX            # Delete the incomplete item with the given index
$ ./docket done INDEX           # Mark the incomplete item with the given index as complete
$ ./docket help                 # Show usage
$ ./docket report               # Statistics''')

Next, we'll define our program for adding new items. Put a condition that says if our input1 is "add" and our input2 is default (which is -1 for input2, which helps us write our task), then write and store the input2 string in our task.txt file. The task's text should be enclosed by double quotations (otherwise only the first word is considered as the item text, and the remaining words are treated as different arguments).

# Add a new item

elif(args.input1 == 'add' and args.input2 != '-1'):
    task.write(str(args.input2) +"\n")
    print('Added task: '+ (args.input2))

The following step is to write code to display a list of all pending items. If input1 is "ls" (which represents a list) and the length of our line in task.txt is larger than 0, then read each line in task.txt with relevant indexes. If your input1 is ls but the length of the line in task.txt is not defined or 0 then print the no pending task message.

# List all pending items

elif(args.input1 == 'ls'and t>0):
    for i in range(t,0,-1):
        line = task_data[i-1].strip()
        print(str(i)+'. '+line)

elif(args.input1 == 'ls'):
    print("There are no pending tasks!")

We've reached the halfway. Bingo!! Begin by defining our condition for removing an item from a list. Put a condition that says if our input1 is del (which means delete) and our input2 is not default but is an integer larger than 0 and less than the length of the line in task.txt, then delete that index line from task.txt. If the index does not exist, an error message is displayed.

# Delete an item

elif(args.input1 == 'del' and args.input2 != '-1' and int(args.input2) <= t and int(args.input2)>0):
    task_data.remove(task_data[int(args.input2)-1])
    task.truncate(0)
    task.seek(0)
    for line in task_data:
        line = line.strip()
        task.write(line+"\n")
    print('Deleted item with index '+(args.input2))

elif(args.input1 == 'del'):
    print("Error: item with index "+str(int(args.input2))+" does not exist. Nothing deleted.")

Its time to mark our task as completed. Lets put a condition if input1 is done and input2 is not default but it is integer greater than 0 and less than equal to the length of line present in task.txt then mark that line as done and remove it from task.txt and store it in completed.txt file, use relevant index to remove and store line. And if index does not exist then show error.

# Mark a task as complete

elif(args.input1 == 'done' and args.input2 != '-1' and int(args.input2) <= t and int(args.input2)>0):
    line = task_data[int(args.input2)-1]
    completed_task.write(task_data[int(args.input2)-1])
    task_data.remove(task_data[int(args.input2)-1])
    task.truncate(0)
    task.seek(0)
    for line in task_data:
        line = line.strip()
        task.write(line+"\n")
    print('Marked item as done.')

elif(args.input1 == 'done'):
    print("Error: no incomplete item with index "+str(int(args.input2))+" exists.")

Finally! We are now ready to generate our report. Huhhh…
Put a condition that says if our input1 is a report, then show all the data in task.txt and completed.txt.

# Generate a Report 

elif(args.input1 == 'report'):
    print("Pending tasks: "+ str(t))
    for i in range(t,0,-1):
        line = task_data[i-1].strip()
        print(str(i)+'. '+ line )
    print("Completed tasks: "+ str(c))
    for i in range(c,0,-1):
        line = completed_data[i-1].strip()
        print(str(i)+'. '+ line )

Tada!! Our cli application is now ready to use. You did it, and I'm delighted it came in handy. The complete source code is available on my github repo. Visit it Once.