DEV Community: Udit Sharma

LazyDesk AI: Breaking Big Tasks into Small Steps with Local AI | Hacktoberfest Week 3

Udit Sharma — Sun, 25 Oct 2026 18:20:45 +0000

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

What I Built

LazyDesk AI is a Python and Streamlit application designed to make everyday tasks easier using local AI. I worked on adding a “Break It Down” mode that turns a large task into smaller, actionable steps.

The goal is to make overwhelming tasks feel easier to start, one small step at a time.

Demo

The feature is currently under development. I have not yet verified a working demo.

Code

Original repository: https://github.com/prarthanas9917/lazydesk-ai

How I Built It

The project uses Python, Streamlit, and Ollama. I extended the task selection interface and added instructions intended to guide the local model to produce 3–7 manageable steps.

Testing and further improvements are still needed.

Why Does Open Innovation Matter?

Open-source AI lets developers learn from existing projects, adapt tools to their needs, and experiment with models that can run locally. Local inference can help keep prompts on a user's own machine instead of sending them to a third-party AI provider.

The Lazy Payoff

The idea is simple: spend less time figuring out where to start and more time taking the first small step. The intended benefit is reducing the effort needed to organize a large task.

Project Status

This is an early contribution. The new mode has been added to the code, but I still need to verify the feature, test the local model integration, and complete the contribution workflow.

GigPilot AI: Turning Client Briefs into Freelance Project Plans

Udit Sharma — Sun, 18 Oct 2026 18:26:55 +0000

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

What I Built

GigPilot AI is a local-first assistant designed to help freelancers turn client messages into structured project plans.

Freelancers often receive rough requirements through WhatsApp messages, emails, or informal conversations. Before starting the actual work, they need to understand the scope, identify missing information, estimate a timeline, prepare a quotation, and respond professionally.

GigPilot AI brings these steps into one workspace. It generates a project summary, suggested deliverables, clarifying questions, potential scope risks, an estimated timeline, a quotation draft, and a client reply.

The goal is to make project planning easier for independent freelancers, designers, developers, and other people offering services online.

Demo

The application runs locally on my machine and uses Ollama for local AI inference.

GitHub repository: https://github.com/uditsharma45/gigpilot-ai

A publicly hosted demo is not available yet. The repository includes the code and setup instructions for running the project locally.

Code

Source code: https://github.com/uditsharma45/gigpilot-ai

The project contains a React and Vite frontend, a Python FastAPI backend, and integration with Ollama for local model inference.

How I Built It

I built GigPilot AI using React, Vite, JavaScript, CSS, Python, FastAPI, and Ollama.

The AI layer uses the open-weight Qwen 2.5 1.5B model, with Gemma 3 1B also configured as an available model.

The frontend provides a workspace where a freelancer can enter a client brief, choose a quotation currency, and request a project plan. The backend sends the brief to the local Ollama service, validates the structured JSON response, and returns the generated project information to the interface.

I tested the backend through FastAPI's interactive documentation. The generation endpoint successfully returned a structured response for a sample clinic website brief.

One important design decision was to keep inference local rather than requiring a hosted AI API. This makes the project useful for experimentation on a personal machine and helps keep client messages local when using the local inference workflow.

The project is still under development, and generated quotations and plans should be reviewed before being sent to clients.

Why Does Open Innovation Matter?

Open innovation makes it possible for developers to experiment with AI without depending entirely on closed, hosted APIs.

Using Ollama and open-weight models gave me the opportunity to run inference locally, inspect how the application communicates with the model, and build a complete workflow around structured AI output.

It also makes the project more approachable for developers who want to learn about AI integration without making a hosted API the only way to run their application.

For a tool that handles client briefs, local inference also offers a practical privacy advantage: messages can remain on the user's machine during local model processing.

Prize Categories

This project is submitted for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle. It focuses on building a practical freelance tool using open-weight AI models and local inference.

PhotoWalk AI: A Photography Challenge That Gets You Outside

Udit Sharma — Sun, 11 Oct 2026 16:14:28 +0000

PhotoWalk AI — Turning Screen Time Into Real-World Exploration

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

What I Built

I built PhotoWalk AI, a web application that encourages people to go outside and turn a normal walk into a photography challenge.

The idea came from something pretty simple: we spend a lot of time looking at photos on our phones, but not enough time actually going outside and creating our own experiences.

PhotoWalk AI gives users a reason to explore their surroundings.

Users can create a PhotoWalk and get creative photography missions such as finding interesting shadows, reflections, colors, or other things around them. They then go outside, complete the mission, and upload their best photographs.

I also built a feature called Color Hunt, where multiple teams can participate in the same photography competition. Each team gets its own target color, and every member of the team goes outside to find and photograph things matching that color.

After the hunt, participants submit their best photographs. The system can evaluate the photographs based on things like color matching, composition, creativity, and technical quality. Teams are then ranked on a leaderboard.

The project also includes winner selection, rewards, and digital participation certificates.

The main idea behind the project is simple:

Instead of using technology only to consume content, use it as a reason to go outside and experience the real world.

PhotoWalk AI is mainly aimed at students, photography enthusiasts, college clubs, friends, and anyone who wants a more creative reason to spend time outdoors.

Demo

The project is currently available as a local web application.

The source code and complete implementation are available on GitHub:

https://github.com/uditsharma45/photowalk-ai

The repository contains both the frontend and backend implementation.

Code

GitHub Repository:

https://github.com/uditsharma45/photowalk-ai

The frontend is built using React and Vite.

The backend is built using FastAPI and Python, with SQLite for storing application data and local storage for uploaded photographs.

The project includes:

PhotoWalk mission creation
Outdoor Walk Mode
Photo uploads
Multi-team Color Hunt
Team and participant management
AI-assisted photo evaluation
Photo scoring
Team leaderboard
Winner selection
Rewards
Digital certificates
Backend API
Automated tests

The backend currently has 51 passing tests, and the frontend production build also completes successfully.

How I Built It

I built PhotoWalk AI as a full-stack web application rather than just a simple AI demo.

The frontend handles the user experience, including creating missions, joining Color Hunts, uploading photographs, viewing scores, and checking the leaderboard.

The FastAPI backend handles the application logic, database operations, photo uploads, competition state, scoring, rewards, and certificates.

For the AI part, I created a separate vision-analysis layer so that the application is not tightly coupled to the rest of the system.

The AI evaluation is designed to look at several aspects of a submitted photograph:

How well it matches the target color
Composition
Creativity
Technical quality

The final photo score is calculated by the backend using weighted scoring:

Color matching: 40%
Composition: 25%
Creativity: 20%
Technical quality: 15%

For team competitions, the system aggregates participant results and creates a leaderboard so that teams can compete against each other.

I also added automated tests for the backend and kept the project structured so that additional AI providers or models can be added later.

The current AI integration uses an OpenAI-compatible vision provider. I have not yet completed a live production AI test because the configured API returned a rate-limit response, so I am not claiming that the live AI evaluation has been fully tested.

Why Does Open Innovation Matter?

For me, open innovation matters because I don't want PhotoWalk AI to be limited to one fixed way of doing things.

The project is open source, so other developers can look at the code, modify the missions, change the scoring system, add new competition formats, or experiment with different AI models.

The AI evaluation system was also separated from the rest of the application so that different vision models and providers can be explored without rebuilding the entire project.

This is especially useful for a project like PhotoWalk AI because image evaluation can be approached in many different ways. Developers could experiment with different models for judging composition, color matching, creativity, or even detecting objects in photographs.

My longer-term goal is to support open-weight and local vision models as well, so that the AI component can be run in different environments instead of depending on a single provider.

My Agent Session

I used AI-assisted development during the development of PhotoWalk AI.

I used it to help with implementation, debugging, architecture, frontend/backend integration, and testing, while I directed the project and decided what features the application should have.

I don't currently have a DevRelay session link to include here.

Prize Categories

I am not entering any additional partner prize category.

I Built ReplyBuddy Because My Friend Never Knows What to Reply

Udit Sharma — Sun, 04 Oct 2026 15:53:32 +0000

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

What I Built

I built ReplyBuddy, a simple AI-powered tool that helps you write better replies to messages.

The idea came from a small but very common problem. Sometimes you know what you want to say, but you are not sure how to say it. You might want to sound friendly without being too casual, professional without sounding robotic, or simply want a short and natural reply.

I built ReplyBuddy for a friend who often spends a lot of time thinking about what to reply to different messages. Instead of opening a general-purpose AI chatbot every time and explaining the whole situation, the idea was to make something focused specifically on that one problem.

With ReplyBuddy, you paste the message you received, choose the kind of response you want, and the AI generates a suitable reply.

For example, if someone sends:

"Can you send me the project files by tonight?"

You can choose a friendly or casual tone and get a response such as:

"Yeah sure, I'll send them over tonight."

The goal is not to replace the way someone communicates. It is simply to help when you have a blank screen and don't know how to phrase something.

Demo

Live Demo: [Add your deployed link here]

The project is currently available on GitHub:

ReplyBuddy GitHub Repository

I will also include a short video demonstration showing the main workflow of the application.

Code

The complete source code is available here:

https://github.com/uditsharma45/replybuddy-ai

The project is open source, so anyone can look at the implementation, run it locally, modify it, or build on top of it.

How I Built It

I wanted to keep the project simple enough for me to understand and build, while still making AI an actual part of the application rather than just adding an AI feature on top of an otherwise unrelated project.

The basic flow is:

The user enters the message they received.
The user selects the tone they want for their reply.
The application sends the message and the selected context to the AI.
The AI generates a natural response.
The user can copy the generated reply and use it in their conversation.

The project is built around an open-source AI model, which is responsible for understanding the incoming message and generating the response.

I intentionally kept the first version focused. Instead of trying to build a huge communication platform, I wanted to solve one small problem properly.

The project also gave me a chance to learn more about connecting a frontend to an AI-powered backend, handling user input, structuring prompts, and thinking about how an AI feature should actually fit into a product.

Why Does Open Innovation Matter?

For a project like ReplyBuddy, open innovation is important because it gives developers the opportunity to experiment with AI without treating the model as a black box that they cannot understand or control.

Using open-source and open-weight AI gives me more freedom to understand how the AI fits into my application and how the project could evolve in the future.

It also makes the project easier for other developers to experiment with. Someone can take the project, change the model, improve the prompting, add new tones, or build completely different features on top of it.

For me, that is one of the most interesting parts of open source. A project does not have to remain exactly the way its original creator built it.

ReplyBuddy started as a small solution for one person's everyday problem, but because it is open source, someone else can take the same idea in a completely different direction.

My Agent Session

I used AI-assisted development while building the project and experimented with different approaches to the application and its AI functionality.

[Add your DevRelay agent session here if you decide to include it.]

Prize Categories

[Add the partner categories you are entering here, or remove this section if none apply.]

Final Thoughts

ReplyBuddy is a relatively small project, but that was intentional.

When I first started thinking about the challenge, I felt like I needed to build something complicated to make it worth submitting. Eventually, I realized that the point of "Build for a Friend" is not necessarily to build the biggest project.

It is about noticing a problem that someone close to you actually has and building something that can make that problem a little easier.

That is what I tried to do with ReplyBuddy.

There are still many things I want to improve, including better context handling, more personalized writing styles, and eventually allowing users to teach the application how they normally communicate.

For now, this is my first version of ReplyBuddy, and I am looking forward to seeing what I can improve next.