DEV Community: Harshit Bajpai

"Slow & Steady 🦥 — An Open-Source AI Helper That Does the Busywork for You"

Harshit Bajpai — Sun, 25 Oct 2026 18:40:46 +0000

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

What I Built

Meet Slow & Steady 🦥, a lightweight AI-powered productivity helper designed to make everyday tasks feel less overwhelming.

The idea is simple: why spend extra energy on tasks that can be made easier?

Slow & Steady offers three shortcuts:

Summarize for me: Turn long text, articles, notes, and messages into concise summaries.
Make it manageable: Break overwhelming tasks into small, actionable steps with a plan tailored to your energy level.
Write it for me: Generate a first draft of a message or email in your preferred tone.

Instead of adding another complicated productivity system to your life, Slow & Steady helps you get started with less effort.

Demo

🦥 Try Slow & Steady here:

https://rage-arch.github.io/Slow-Steady/

Code

Built with simple, lightweight web technologies:

HTML5
CSS3
JavaScript
Ollama for local model inference
Qwen 2.5 3B as the intended default open-weight model

The frontend is designed to connect to a locally running Ollama instance, so users can experiment with AI assistance without depending on a paid, hosted AI API.

How I Built It

I built Slow & Steady using HTML, CSS, and vanilla JavaScript, keeping the interface lightweight and easy to understand.

The application has three core workflows: text summarization, task breakdown, and message drafting. Each workflow collects the user's input and sends a suitable prompt to a locally running Ollama model. The model can be changed through the settings, allowing users to experiment with different compatible models.

The project also includes a basic fallback mode for when the local model is unavailable. This fallback provides simple text extraction or starter content rather than pretending that an AI model generated the result.

The intended local setup uses Ollama with Qwen 2.5 3B, an open-weight model. Once the model has been downloaded and the local environment is configured, inference can run without an internet connection, subject to the setup and browser requirements.

Why Does Open Innovation Matter?

For a project focused on making everyday life easier, AI should not introduce unnecessary costs, complexity, or privacy concerns.

Using open-weight models and local inference gives Slow & Steady several advantages:

More privacy and control: Prompts can be processed on the user's own computer instead of being sent to a third-party AI API.
Less dependence on paid services: There is no need for a paid hosted AI API, although running a local model still uses computing resources.
Freedom to experiment: Users can switch compatible models and customize prompts to suit their needs.
Offline potential: After downloading the model and configuring the environment, AI inference can work without an internet connection.
Accessible development: The project uses familiar web technologies, making it easier for other developers to inspect, learn from, and extend.

A closed API can be convenient, but it often makes the application dependent on an external service. With an open-based approach, the user has more control over where inference happens and how the tool evolves.

For me, open innovation means building tools that people can adapt to their own needs instead of forcing everyone into the same system.

The Lazy Payoff 🦥

Slow & Steady is built around one small principle: make the next step easier.

Instead of manually condensing a long document, users can request a summary. Instead of staring at an overwhelming to-do list, they can generate a manageable checklist. Instead of struggling to start a message, they can create a first draft and personalize it.

The goal isn't to turn every spare minute into more work. It's to reduce the friction involved in everyday tasks and leave people with more time and energy for what matters to them.

Sometimes, being productive means finding a better way to do less.

Final Thoughts

Slow & Steady is my take on practical, open-based AI: a small assistant that prioritizes simplicity, user control, and less busywork.

Because not everything needs to be done the hard way.

Move slowly. Build thoughtfully. Let AI handle the busywork. 🦥🌿

Hacktoberfest #OpenSourceAI #BuildInPublic

SoloDesk — Your AI-Powered Freelance Workspace

Harshit Bajpai — Thu, 15 Oct 2026 09:37:40 +0000

What I Built

SoloDesk is an AI-powered freelance workspace designed to help freelancers and independent professionals manage their work more efficiently.

Freelancers often spend too much time handling administrative tasks instead of focusing on their actual work. Managing invoices, tracking payments, writing professional messages, and keeping business information organized can quickly become overwhelming.

I built SoloDesk to bring these workflows together in one place, with AI assistance to make everyday tasks simpler.

Key Features

Freelance Dashboard: A central place to monitor business activity and important information.

Invoice Management: Organize invoices and keep track of payments.

AI Payment Reminders: Generate personalized payment reminder drafts.

AI Writing Assistant: Improve service descriptions, polish text, and turn rough notes into clearer writing.

Open-Source AI Integration: Build AI-assisted workflows around open-weight models rather than depending entirely on a proprietary AI API.

Who Is It For?

SoloDesk is designed for freelancers, independent developers, designers, consultants, and solo entrepreneurs who want a simpler way to manage everyday business tasks.

The long-term goal is to make freelance administration less time-consuming and provide a practical alternative to juggling multiple tools.

Potential business model: A free basic version with optional paid features, customization, or premium productivity tools.

Demo

🚀 Live Website: https://rage-arch.github.io/SoloDesk/

Explore SoloDesk and its interface for freelance management and AI-assisted productivity.

Code

💻 GitHub Repository: https://github.com/RagE-arch/SoloDesk.git
The project is built around web technologies, with a focus on creating a straightforward and accessible workspace for independent professionals.

Explore the repository to see the implementation and follow the project's development.

How I Built It

I built SoloDesk using HTML, CSS, and JavaScript, with Node.js for backend functionality and a local AI workflow designed around Ollama and the Qwen2.5:3b model.

Technology Stack

Frontend: HTML, CSS, JavaScript

Backend: Node.js

Open-Weight Model: Qwen2.5:3b

Local AI Runtime: Ollama

Deployment: GitHub Pages for the public website

The goal was to combine a practical freelance workspace with AI-powered assistance.

Instead of making a proprietary, cloud-hosted AI API the only way to provide AI functionality, the project explores how an open-weight model can support useful everyday workflows.

The AI-assisted features focus on tasks such as drafting payment reminders and improving written content, helping users reduce repetitive work.

Why Does Open Innovation Matter?

For me, open innovation is about having the freedom to build, experiment, and customize without being entirely dependent on a single AI provider.

Using open-weight AI models creates opportunities for:

Cost control: Local inference can reduce dependence on per-request API fees, although hardware and electricity still have costs.

Customization: Developers can experiment with prompts, model configurations, and AI workflows.

Greater control over data: A correctly configured local inference setup can process prompts on the user's machine rather than sending them to an external AI provider.

Reduced vendor lock-in: The AI implementation can potentially be adapted to other compatible models and runtimes.

Accessibility: Independent developers can experiment with AI-powered products without necessarily needing a paid commercial API.

For a tool designed for freelancers, these advantages matter. Small independent businesses need practical tools that are affordable, adaptable, and useful.

A closed AI API can also provide excellent results, but open-weight models offer another path: greater control over the inference environment and the freedom to experiment with how the technology is used.

My biggest takeaway: Open innovation makes it possible to explore AI-powered productivity tools while retaining more control over the technology behind them.

SoloDesk is my attempt to turn that flexibility into something useful for people who manage their own work and businesses.

My Agent Session

DevRelay Session:

Create a DevRelay Session URL

You

create a session url using devrelay

Agent

Checked the DevRelay session workflow, then submitted this minimal transcript through DevRelay to create a shareable session.

I used AI-assisted development while building and refining SoloDesk. My development process involved turning the project idea into a working interface and integrating AI-assisted functionality into a practical freelance workflow.

Create a DevRelay Session URL

You

create a session url using devrelay

Agent

Checked the DevRelay session workflow, then submitted this minimal transcript through DevRelay to create a shareable session.

Project: SoloDesk
Challenge: Hacktoberfest Open-Source AI Challenge — Week 2: Side Hustle

Verdant AI — Intelligence Rooted in Nature

Harshit Bajpai — Fri, 09 Oct 2026 11:13:45 +0000

🌿 Verdant AI — Intelligence Rooted in Nature

LIVE WEBSITE - https://rage-arch.github.io/verdant-AI/

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

What I Built

Verdant AI is an AI-powered nature companion designed to help people spend less time scrolling and more time exploring the world around them.

In a world where we spend hours looking at screens, Verdant AI turns technology into a bridge to the outdoors rather than a distraction from it.

🌱 What it offers:

AI Nature Guide: Ask questions about plants, ecosystems, leaves, and the natural world using a locally running open-weight AI model.
Outdoor Field Missions: Complete seven screen-free challenges that encourage you to observe leaves, listen to nature, notice clouds, explore colors, and discover local habitats.
Digital Field Journal: Record discoveries and observations, track completed missions, and export your journal as a JSON file.
Privacy-Focused Experience: Journal entries are stored locally in your browser, while the AI guide can run on your own computer without a hosted AI API.
Offline-First Design: After the necessary setup and model download, the local AI can work without an internet connection, provided the app server and model are running.

Verdant AI is designed for students, nature enthusiasts, curious beginners, and anyone who wants a simple reason to step outside and reconnect with their surroundings.

The goal is simple: use AI to encourage real-world experiences, not replace them.

Demo

🌐 Live Website: https://rage-arch.github.io/verdant-AI/

💻 GitHub Repository: https://github.com/RagE-arch/verdant-AI

The hosted website showcases the interface. The full local AI chat functionality requires running the project with Node.js and Ollama, as explained in the repository's README.

Code

Explore the complete source code in the public repository:

Verdant AI on GitHub

The project is built with:

HTML for the application structure
CSS for responsive layouts and visual design
JavaScript for missions, navigation, journaling, and AI interactions
Node.js for the local server and AI request handling
Ollama for running the AI model locally

The repository includes the application files, setup instructions, service worker, web app manifest, and MIT license for the app code.

How I Built It

The core of Verdant AI is Qwen2.5-1.5B-Instruct, an open-weight language model that runs locally through Ollama.

Instead of relying on a hosted AI API, I designed the application around a local architecture:

Frontend: HTML, CSS, and JavaScript create the dashboard, nature guide, outdoor missions, and field journal.
Local backend: A Node.js server serves the application and handles chat requests.
AI inference: The server sends questions to the local Ollama API, which runs the configured Qwen model.
Local data storage: The field journal and mission progress are saved in browser storage.
Offline support: A service worker caches the application shell after the first visit, while Ollama manages the downloaded model separately.

The app also uses a nature-focused system prompt that encourages concise educational answers, acknowledges uncertainty, and discourages unsafe interactions with unfamiliar plants and wildlife.

One important distinction: the first setup requires downloading the software and model. Afterward, local AI inference can work offline while the necessary local services are running.

Why Does Open Innovation Matter?

Open innovation matters because an application about reconnecting with nature should not require constant connectivity or send every question to a remote AI provider.

Using an open-weight model and local inference makes several things possible:

More control: Developers can inspect the architecture, change the model, and customize the AI's behavior.
Privacy by design: Questions can be processed locally, and journal entries remain in browser storage rather than being uploaded to a hosted journal service.
Reduced dependency: The local AI guide does not require a paid hosted AI API key.
Offline potential: Once the model and software are installed, the AI can continue working without an internet connection.
Community collaboration: Open-source code allows other developers to study, adapt, improve, and extend the project.

A closed API could provide similar conversational features, but it would introduce a dependency on a remote provider and its availability, pricing, and data-handling policies.

For Verdant AI, openness is not just a development choice. It supports the project's goal of making nature education more accessible, adaptable, and privacy-conscious.

My Agent Session

I have not included a DevRelay agent session in this submission.

The source code and README are available in the GitHub repository for reviewing the implementation and setup process.

Prize Categories

Overall Challenge: Open-Source AI — Touch Grass

I am submitting Verdant AI for the overall challenge.

I am not claiming a partner-specific prize category at this time, as the current implementation uses Qwen2.5 through Ollama rather than one of the listed partner technologies.

🌎 Final Thought

Technology doesn't always have to keep us indoors.

Sometimes, the best thing an AI can do is answer a question, suggest something worth noticing, and encourage us to put the phone away.

Verdant AI — Intelligence rooted in nature. 🌿

Hacktoberfest #OpenSourceAI #AI #Qwen #Ollama #WebDev #BuildInPublic #TouchGrass