DEV Community: Ayush Tripathi

I Built HustleWrite AI: A Local-First AI Listing Generator for Small Sellers | Hacktoberfest Week 2

Ayush Tripathi — Mon, 19 Oct 2026 05:49:42 +0000

HustleWrite AI: A Local-First AI Tool for Small Business Owners

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

What I Built

HustleWrite AI is a small AI-powered tool designed to help small business owners and online sellers create product descriptions and marketing captions without spending too much time writing them manually.

Many small sellers have great products but struggle to write attractive descriptions for their online stores and social media pages. Hiring a copywriter or paying for multiple AI subscriptions isn't always practical when you're just starting out.

I wanted to explore whether an open-weight AI model could make this process simpler and more accessible.

With HustleWrite AI, users can provide basic product information and generate content tailored to their products and target audience.

Why I Built It

The idea behind this project is to build something small that solves a real problem.

A freelancer, a local shop owner, or someone running a small online business shouldn't need an expensive AI subscription just to write a product description.

I also wanted to experiment with open-source AI beyond simply calling a hosted AI API.

How It Uses Open-Source AI

The project is designed to use an open-weight language model through Ollama.

Instead of depending on a proprietary AI API, the application can send prompts to a locally running model. This approach offers several advantages:

Privacy: Product information can remain on the user's machine when inference is performed locally.
Cost control: Local inference avoids per-request API charges, although hardware and electricity still have costs.
Model flexibility: Users can experiment with different compatible open-weight models.
Control: The generation process can be customized for specific types of sellers and products.

The model's actual license determines how it can be used and distributed, so that needs to be checked before commercial deployment.

Tech Stack

React and Vite for the frontend
CSS for the user interface
Node.js for application integration, where needed
Ollama for running an open-weight language model locally

What Makes It Useful as a Side Hustle?

The initial version focuses on product descriptions and marketing captions.

A future version could include bulk listing generation, reusable brand voice profiles, marketplace-specific templates, and export options.

These features could make the tool useful for small sellers who regularly create product listings.

The goal is not to compete with every general-purpose AI platform. It is to make one repetitive task easier for a specific group of users.

What I Learned

This project is an opportunity to explore how open-weight models can power practical applications while giving developers more control over privacy, cost, and customization.

It also highlights an important distinction: using an AI model is only part of building a useful product. The workflow around that model needs to solve a real problem.

What's Next?

I would like to test the application with a small business owner or an online seller, collect feedback, and understand which features would genuinely save them time.

If I continue developing it, I would prioritize improvements based on that feedback rather than adding features just for the sake of it.

This project is my contribution to the Hacktoberfest Open-Source AI Challenge: Week 2 — Side Hustle.

I'd love to hear how you would improve a local-first AI tool for small business owners.

# TrailMate AI: An Open-Weight AI Companion That Gets You Outside

Ayush Tripathi — Sun, 11 Oct 2026 18:40:28 +0000

What I Built

We spend a lot of time on our phones, whether we're scrolling through social media, watching videos, or looking for something interesting to do. Sometimes, we end up spending more time on our screens than we intended.

That got me thinking: what if we used AI to encourage people to do the opposite?

That's the idea behind TrailMate AI, a small project I built for the Touch Grass challenge. It is a nature companion designed to help people take a break from their screens, go outside, and pay more attention to their surroundings.

The idea is to make going outside a little more interesting. Instead of simply going for a walk, you could have a small activity to try, something new to observe, or a question to explore.

The project includes three main features:

Nature Missions: Generate simple outdoor activities based on interests such as plants, leaves, birds, clouds, and gardening.

Ask Nature: Ask questions about the natural world and learn something new.

Field Journal: Record interesting things you noticed during your walk and revisit those observations later.

I wanted to keep the experience simple. Get an idea, read the instructions, put your phone away, and go explore.

Demo

You can find the project source code here:

TrailMate AI on GitHub Code

The complete source code is available in my public GitHub repository:

https://github.com/ayushtripathi15567/trailmate-ai

The repository contains the frontend, backend, and instructions for setting up the project locally.

How I Built It

I built TrailMate AI using React and Vite for the frontend and Python with Flask for the backend.

For the AI component, I chose Gemma, an open-weight model that can be run locally using Ollama.

The basic workflow is straightforward. A user selects an interest and the amount of time they have available. The backend sends a prompt to the locally running model, which generates a nature-related activity. Users can also ask questions about nature through the application.

The field journal uses browser local storage, allowing users to save their observations without needing a separate database for that feature.

I wanted to keep the project relatively lightweight and use technologies that other developers could run and experiment with themselves.

Why Does Open Innovation Matter?

One of the reasons I wanted to explore open-weight AI was the flexibility it offers developers.

When building with a closed AI API, you generally depend on the provider for model access and the way the service is delivered. With an open-weight model, you have more freedom to experiment with prompts, choose compatible models, and run inference on your own hardware.

For TrailMate AI, local inference is particularly interesting because the application is intended to encourage people to spend time away from their screens.

Running a model locally can reduce dependence on external AI services and limit the need to send every question to a third-party provider. It can also avoid per-request API charges, although local inference still requires suitable hardware and electricity.

Another benefit is that the project can be extended by other developers. Someone could adapt the same idea for birdwatching, gardening, hiking, or environmental education.

I like that open-source development makes this kind of experimentation more accessible. Developers can learn from the implementation, modify it to suit their needs, and build on top of it rather than starting from scratch.

For me, the interesting part is not just using an AI model. It is exploring how that model can be used to encourage a real-world activity instead of creating another reason to stay online.

My Agent Session

I haven't included a DevRelay agent session in this submission.

Prize Categories

Gemma — Best Use of Gemma

I plan to enter this category because the project is designed around using Gemma as its open-weight AI model. The final submission should reflect the model integration and features I have actually tested.

Final Thoughts

This project started with a simple question: can we use AI to help people spend less time on their phones?

TrailMate AI is my attempt at exploring that idea. It is a small project, but it gave me an opportunity to experiment with open-weight AI, connect a frontend to a backend, and think about how technology can encourage people to engage with the world outside their screens.

I also see plenty of room to improve it, from adding more nature activities to exploring ways to make it useful for people who enjoy hiking, gardening, or simply taking a walk.

That is one of the things I enjoy about building projects: starting with a small idea, turning it into something tangible, and learning along the way.

Thanks for reading. I'd love to hear your thoughts and suggestions for improving TrailMate AI.

CodeBuddy: An AI That Helps You Solve Coding Problems Without Spoiling Them

Ayush Tripathi — Mon, 05 Oct 2026 06:58:59 +0000

What I Built

I built CodeBuddy, a Socratic competitive-programming practice partner powered by open-weight AI.

I built it around a problem I've experienced while practicing competitive programming: when you get stuck on a problem, asking an AI for the complete solution is often the easiest option.

You get the answer, but you don't necessarily get better at solving the next problem.

CodeBuddy takes a different approach.

Instead of immediately revealing the solution, it helps the learner reason through the problem using progressively stronger hints:

Problem → Think → Small Hint → Stronger Hint → Key Idea → Solution

The learner can provide a problem and describe their current approach. CodeBuddy then acts as a practice partner rather than simply providing an answer.

I also built a C++ code-review mode that analyzes submitted code for correctness, potential issues, edge cases, and time and space complexity.

The goal is simple:

Help someone learn how to solve the problem instead of solving the problem for them.

Demo

The project is currently available as a working local MVP.

Repository: https://github.com/ayushtripathi15567/CodeBuddy

The repository contains the complete frontend, backend, model integration, setup instructions, and deployment configuration.

Code

GitHub: https://github.com/ayushtripathi15567/CodeBuddy

The project is built with React/Vite on the frontend and Flask on the backend.

How I Built It

The core AI component is designed around Gemma, Google's open-weight model.

The application is structured as:

User
  ↓
React / Vite Frontend
  ↓
Flask Backend
  ↓
Gemma
  ↓
Hint / Code Review

I designed the prompting behavior around a Socratic tutoring approach.

For example, instead of asking the model to simply solve a problem, CodeBuddy can ask it to provide a single subtle hint without revealing the complete algorithm.

The user can then request a stronger hint or the key idea when they need more help.

The code-review workflow asks the model to analyze C++ submissions for:

Correctness
Potential bugs
Edge cases
Time complexity
Space complexity
Possible improvements

The project also keeps the model layer replaceable, allowing the inference setup to evolve as different open-weight models become available.

Why Does Open Innovation Matter?

For CodeBuddy, the AI model is not just a black-box API.

The behavior of the tutor is the product.

I want to be able to control how the AI teaches, how much information it reveals, how it gives hints, and how it reviews a learner's reasoning.

Using an open-weight model makes that much more flexible.

It gives me the ability to:

Experiment with different open models.
Change the tutoring behavior and prompts.
Move toward local inference.
Reduce dependence on a single closed AI provider.
Potentially keep a learner's code and practice data local.

That flexibility is especially useful for a project like CodeBuddy because it is designed around a very specific person and their learning style rather than a generic AI chatbot.

Open innovation makes it possible to keep adapting the tool around the learner.

My Agent Session

Not included in this submission.

Prize Categories

Gemma — Best Use of Gemma

CodeBuddy uses Gemma as the open-weight AI model at the core of its tutoring and code-review workflows.

Building CodeBuddy made me think differently about what an AI coding assistant should do.

The fastest assistant isn't always the best teacher.

Sometimes the better assistant is the one that gives you just enough of a hint to make you solve the problem yourself.

Hello, DEV!

Ayush Tripathi — Thu, 01 Oct 2026 15:07:09 +0000

Hi everyone,

I'm Ayush, a Computer Science graduate and a competitive programmer interested in problem solving and software development.

I've recently started exploring this community to learn from other developers, share what I learn, and document my journey along the way.

Looking forward to connecting with everyone here.